To see the other types of publications on this topic, follow the link: Programming Languages, Event.
Journal articles on the topic 'Programming Languages, Event'
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 journal articles for your research on the topic 'Programming Languages, Event.'
Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.
You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.
Browse journal articles on a wide variety of disciplines and organise your bibliography correctly.
1
Nance, Richard E. "A history of discrete event simulation programming languages." ACM SIGPLAN Notices 28, no. 3 (March 1993): 149–75. http://dx.doi.org/10.1145/155360.155368.
Full text
2
Lukkarinen, Aleksi, Lauri Malmi, and Lassi Haaranen. "Event-driven Programming in Programming Education." ACM Transactions on Computing Education 21, no. 1 (March 2021): 1–31. http://dx.doi.org/10.1145/3423956.
Full textAbstract:
During the past two decades, event-driven programming (EDP) has emerged as a central and almost ubiquitous concept in modern software development: Graphical user interfaces are self-evident in most mobile and web-based applications, as well as in many embedded systems, and they are most often based on reacting to events. To facilitate both teaching practice and research in programming education, this mapping review seeks to give an overview of the related knowledge that is already available in conference papers and journal articles. Starting from early works of the 1990s, we identified 105 papers that address teaching practices, present learning resources, software tools or libraries to support learning, and empirical studies related to EDP. We summarize the publications, their main content, and findings. While most studies focus on bachelor’s level education in universities, there has been substantial work in K-12 level, as well. Few courses address EDP as their main content—rather it is most often integrated with CS1, CS2, or computer graphics courses. The most common programming languages and environments addressed are Java, App Inventor, and Scratch. Moreover, very little of deliberate experimental scientific research has been carried out to explicitly address teaching and learning EDP. Consequently, while so-called experience reports, tool papers, and anecdotal evidence have been published, this theme offers a wide arena for empirical research in the future. At the end of the article, we suggest a number of directions for future research.
3
Cuenca, Fredy, Jan Van den Bergh, Kris Luyten, and Karin Coninx. "Hasselt." International Journal of People-Oriented Programming 5, no. 1 (January 2016): 19–38. http://dx.doi.org/10.4018/ijpop.2016010102.
Full textAbstract:
Implementing multimodal interactions with event-driven languages results in a ‘callback soup', a source code littered with a multitude of flags that have to be maintained in a self-consistent manner and across different event handlers. Prototyping multimodal interactions adds to the complexity and error sensitivity, since the program code has to be refined iteratively as developers explore different possibilities and solutions. The authors present a declarative language for rapid prototyping multimodal interactions: Hasselt permits declaring composite events, sets of events that are logically related because of the interaction they support, that can be easily bound to dedicated event handlers for separate interactions. The authors' approach allows the description of multimodal interactions at a higher level of abstraction than event languages, which saves developers from dealing with the typical ‘callback soup' thereby resulting in a gain in programming efficiency and a reduction in errors when writing event handling code. They compared Hasselt with using a traditional programming language with strong support for events in a study with 12 participants each having a solid background in software development. When performing equivalent modifications to a multimodal interaction, the use of Hasselt leads to higher completion rates, lower completion times, and less code testing than when using a mainstream event-driven language.
4
Kiviat, Philip. "A brief introduction to discrete-event simulation programming languages." ACM SIGPLAN Notices 28, no. 3 (March 1993): 369–70. http://dx.doi.org/10.1145/155360.155400.
Full text
5
Achten, Peter, and Rinus Plasmeijer. "The ins and outs of Clean I/O." Journal of Functional Programming 5, no. 1 (January 1995): 81–110. http://dx.doi.org/10.1017/s0956796800001258.
Full textAbstract:
AbstractFunctional programming languages have banned assignment because of its undesirable properties. The reward of this rigorous decision is that functional programming languages are side-effect free. There is another side to the coin: because assignment plays a crucial role in Input/Output (I/O), functional languages have a hard time dealing with I/O. Functional programming languages have therefore often been stigmatised as inferior to imperative programming languages because they cannot deal with I/O very well. In this paper, we show that I/O can be incorporated in a functional programming language without loss of any of the generally accepted advantages of functional programming languages. This discussion is supported by an extensive account of the I/O system offered by the lazy, purely functional programming language Clean. Two aspects that are paramount in its I/O system make the approach novel with respect to other approaches. These aspects are the technique of explicit multiple environment passing, and the Event I/O framework to program Graphical User I/O in a highly structured and high-level way. Clean file I/O is as powerful and flexible as it is in common imperative languages (one can read, write, and seek directly in a file). Clean Event I/O provides programmers with a high-level framework to specify complex Graphical User I/O. It has been used to write applications such as a window-based text editor, an object based drawing program, a relational database, and a spreadsheet program. These graphical interactive programs are completely machine independent, but still obey the look-and-feel of the concrete window environment being used. The specifications are completely functional and make extensive use of uniqueness typing, higher-order functions, and algebraic data types. Efficient implementations are present on the Macintosh, Sun (X Windows under Open Look) and PC (OS/2).
6
Reznikova, Sofia, Victor Rivera, Joo Young Lee, and Manuel Mazzara. "Translation from Event-B into Eiffel." Modeling and Analysis of Information Systems 25, no. 6 (December 19, 2018): 623–36. http://dx.doi.org/10.18255/1818-1015-2018-6-623-636.
Full textAbstract:
Formal modelling languages play a key role in the development of software: they enable users to specify functional requirements that serve as documentation as well; they enable users to prove the correctness of system properties, especially for critical systems. However, there is still an open question on how to map formal models to a specific programming language. In order to propose a solution, this paper presents a source-to-source mapping between Event-B models, a formal modelling language for reactive systems, and Eiffel programs, an Object Oriented (O-O) programming language. The mapping not only generates an actual Eiffel code of the Event-B model, but also translates model properties as contracts. The contracts follow the Design by Contract principle and are natively supported by the programming language. The mapping is implemented in the freely available Rodin plug-in EB2Eiffel. Thus, users can develop systems (i) starting with the modelling of functional requirements (properties) in Event-B, then (ii) formally proving the correctness of such properties in Rodin and finally (iii) by using EB2Eiffel to translate the model into Eiffel. In Eiffel, users can extend/customise the implementation of the model and formally prove it against the initial model. This paper also presents different Event-B models from the literature to test EB2Eiffel and its limitations. The article is published in the authors’ wording.
7
Paschke, Adrian. "A Report on the Ninth International Web Rule Symposium." AI Magazine 37, no. 1 (April 13, 2016): 105–6. http://dx.doi.org/10.1609/aimag.v37i1.2634.
Full textAbstract:
The annual International Web Rule Symposium (RuleML) is an international conference on research, applications, languages and standards for rule technologies. RuleML is a leading conference to build bridges between academe and industry in the field of rules and its applications, especially as part of the semantic technology stack. It is devoted to rule-based programming and rule-based systems including production rules systems, logic programming rule engines, and business rule engines/business rule management systems; semantic web rule languages and rule standards; rule-based event processing languages (EPLs) and technologies; and research on inference rules, transformation rules, decision rules, production rules, and ECA rules. The 9th International Web Rule Symposium (RuleML 2015) was held in Berlin, Germany, August 2-5. This report summarizes the events of that conference.
8
Grzanek, Konrad. "Low-Cost Dynamic Constraint Checking for the JVM." Journal of Applied Computer Science Methods 8, no. 2 (December 1, 2016): 115–36. http://dx.doi.org/10.1515/jacsm-2016-0008.
Full textAbstract:
Abstract Using formal methods for software verification slowly becomes a standard in the industry. Overall it is a good idea to integrate as many checks as possible with the programming language. This is a major cause of the apparent success of strong typing in software, either performed on the compile time or dynamically, on runtime. Unfortunately, only some of the properties of software may be expressed in the type system of event the most sophisticated programming languages. Many of them must be performed dynamically. This paper presents a flexible library for the dynamically typed, functional programming language running in the JVM environment. This library offers its users a close to zero run-time overhead and strong mathematical background in category theory.
9
KOUZAPAS, DIMITRIOS, NOBUKO YOSHIDA, RAYMOND HU, and KOHEI HONDA. "On asynchronous eventful session semantics." Mathematical Structures in Computer Science 26, no. 2 (November 10, 2014): 303–64. http://dx.doi.org/10.1017/s096012951400019x.
Full textAbstract:
Event-driven programming is one of the major paradigms in concurrent and communication-based programming, where events are typically detected as the arrival of messages on asynchronous channels. Unfortunately, the flexibility and performance of traditional event-driven programming come at the cost of more complex programs: low-level APIs and the obfuscation of event-driven control flow make programs difficult to read, write and verify.This paper introduces a π-calculus with session types that modelsevent-driven session programming(called ESP) and studies its behavioural theory. The main characteristics of the ESP model are asynchronous, order-preserving message passing, non-blocking detection of event/message arrivals and dynamic inspection of session types. Session types offer formal safety guarantees, such as communication and event handling safety, and programmatic benefits that overcome problems with existing event-driven programming languages and techniques. The new typed bisimulation theory developed for the ESP model is distinct from standard synchronous or asynchronous bisimulation, capturing the semantic nature of eventful session-based processes. The bisimilarity coincides with reduction-closed barbed congruence.We demonstrate the features and benefits of ESP and the behavioural theory through two key use cases. First, we examine an encoding and the semantic behaviour of the event selector, a central component of general event-driven systems, providing core results for verifying type-safe event-driven applications. Second, we examine the Lauer–Needham duality, building on the selector encoding and bisimulation theory to prove that a systematic transformation from multithreaded to event-driven session processes is type- and semantics-preserving.
10
BIKAKIS, ANTONIS, PAUL FODOR, ADRIAN GIURCA, and LEORA MORGENSTERN. "Introduction to the special issue on the International Web Rule Symposia 2012–2014." Theory and Practice of Logic Programming 16, no. 3 (March 7, 2016): 243–46. http://dx.doi.org/10.1017/s1471068416000028.
Full textAbstract:
The annual International Web Rule Symposium (RuleML) is an international conference on research, applications, languages, and standards for rule technologies. It has evolved from an annual series of international workshops since 2002, international conferences in 2005 and 2006, and international symposia since 2007. It is the flagship event of the Rule Markup and Modeling Initiative (RuleML, http://ruleml.org), a nonprofit umbrella organization of several technical groups from academia, industry, and government working on rule technology and its applications. RuleML is the leading conference to build bridges between academia and industry in the field of rules and its applications, especially as part of the semantic technology stack. It is devoted to rule-based programming and rule-based systems including production rules systems, logic programming rule engines, and business rules engines/business rules management systems; Semantic Web rule languages and rule standards (e.g., RuleML, SWRL, RIF, PRR, SBVR, DMN, CL, Prolog); rule-based event processing languages and technologies; and research on inference rules, transformation rules, decision rules, production rules, and ECA rules.
11
Dwyer, David J. "Issues in African Academic Language Programming in the U.S." Issue: A Journal of Opinion 25, no. 1 (1997): 23–28. http://dx.doi.org/10.1017/s0047160700502479.
Full textAbstract:
Support for academic African language programs (ALPs) in the US began at the national level with the National Defense Education Act of 1958 (renamed the Higher Education Act of 1965). The goal of this legislation was to establish a world-wide language and area studies knowledge base that could be called upon in the event of conflict, but in addition it has provided generations of students a wealth of knowledge about the less commonly taught languages (LCTLs) and the communities where they are spoken. Although the Africa region’s share of this support has hovered around 12%, its effect has been substantial. For example, based on a world-wide listing of Africanist linguists, approximately half of these specialists live in Africa, with the remainder being equally divided between the countries of Europe and the US, a remarkable fact given that the US has no colonial legacy in Africa. Title VI of this legislation supports a set of National Resource Centers (NRCs) that promote language and area study of a specific region including Africa.
12
LANGEVINE, LUDOVIC, and MIREILLE DUCASSÉ. "Design and implementation of a tracer driver: Easy and efficient dynamic analyses of constraint logic programs." Theory and Practice of Logic Programming 8, no. 5-6 (November 2008): 581–609. http://dx.doi.org/10.1017/s147106840800344x.
Full textAbstract:
AbstractTracers provide users with useful information about program executions. In this article, we propose a “tracer driver”. From a single tracer, it provides a powerful front-end enabling multiple dynamic analysis tools to be easily implemented, while limiting the overhead of the trace generation. The relevant execution events are specified by flexible event patterns and a large variety of trace data can be given either systematically or “on demand”. The proposed tracer driver has been designed in the context of constraint logic programming (CLP); experiments have been made within GNU-Prolog. Execution views provided by existing tools have been easily emulated with a negligible overhead. Experimental measures show that the flexibility and power of the described architecture lead to good performance. The tracer driver overhead is inversely proportional to the average time between two traced events. Whereas the principles of the tracer driver are independent of the traced programming language, it is best suited for high-level languages, such as CLP, where each traced execution event encompasses numerous low-level execution steps. Furthermore, CLP is especially hard to debug. The current environments do not provide all the useful dynamic analysis tools. They can significantly benefit from our tracer driver which enables dynamic analyses to be integrated at a very low cost.
13
Lee, J., and R. Palla. "Reformulating the Situation Calculus and the Event Calculus in the General Theory of Stable Models and in Answer Set Programming." Journal of Artificial Intelligence Research 43 (April 24, 2012): 571–620. http://dx.doi.org/10.1613/jair.3489.
Full textAbstract:
Circumscription and logic programs under the stable model semantics are two well-known nonmonotonic formalisms. The former has served as a basis of classical logic based action formalisms, such as the situation calculus, the event calculus and temporal action logics; the latter has served as a basis of a family of action languages, such as language A and several of its descendants. Based on the discovery that circumscription and the stable model semantics coincide on a class of canonical formulas, we reformulate the situation calculus and the event calculus in the general theory of stable models. We also present a translation that turns the reformulations further into answer set programs, so that efficient answer set solvers can be applied to compute the situation calculus and the event calculus.
14
García-Blas, Javier, and Christopher Brown. "High-level programming for heterogeneous and hierarchical parallel systems." International Journal of High Performance Computing Applications 32, no. 6 (November 2018): 804–6. http://dx.doi.org/10.1177/1094342018807840.
Full textAbstract:
High-Level Heterogeneous and Hierarchical Parallel Systems (HLPGPU) aims to bring together researchers and practitioners to present new results and ongoing work on those aspects of high-level programming relevant, or specific to general-purpose computing on graphics processing units (GPGPUs) and new architectures. The 2016 HLPGPU symposium was an event co-located with the HiPEAC conference in Prague, Czech Republic. HLPGPU is targeted at high-level parallel techniques, including programming models, libraries and languages, algorithmic skeletons, refactoring tools and techniques for parallel patterns, tools and systems to aid parallel programming, heterogeneous computing, timing analysis and statistical performance models.
15
Mun, S. H., M. R. Ahmad, R. F. Malik, M. R. M. Esa, M. H. M. Sabri, D. Periannan, B. Y. Seah, et al. "Performance Analysis of Real Time Image Processing for Lightning Event Using Cython and Python Programming Languages." IOP Conference Series: Earth and Environmental Science 228 (February 15, 2019): 012009. http://dx.doi.org/10.1088/1755-1315/228/1/012009.
Full text
16
LOPES, NUNO P., JUAN A. NAVARRO, ANDREY RYBALCHENKO, and ATUL SINGH. "Applying Prolog to develop distributed systems." Theory and Practice of Logic Programming 10, no. 4-6 (July 2010): 691–707. http://dx.doi.org/10.1017/s1471068410000360.
Full textAbstract:
AbstractDevelopment of distributed systems is a difficult task. Declarative programming techniques hold a promising potential for effectively supporting programmer in this challenge. While Datalog-based languages have been actively explored for programming distributed systems, Prolog received relatively little attention in this application area so far. In this paper we present a Prolog-based programming system, called DAHL, for the declarative development of distributed systems. DAHL extends Prolog with an event-driven control mechanism and built-in networking procedures. Our experimental evaluation using a distributed hash-table data structure, a protocol for achieving Byzantine fault tolerance, and a distributed software model checker—all implemented in DAHL—indicates the viability of the approach.
17
Magnusson, Thor. "Algorithms as Scores: Coding Live Music." Leonardo Music Journal 21 (December 2011): 19–23. http://dx.doi.org/10.1162/lmj_a_00056.
Full textAbstract:
The author discusses live coding as a new path in the evolution of the musical score. Live-coding practice accentuates the score, and whilst it is the perfect vehicle for the performance of algorithmic music it also transforms the compositional process itself into a live event. As a continuation of 20th-century artistic developments of the musical score, live-coding systems often embrace graphical elements and language syntaxes foreign to standard programming languages. The author presents live coding as a highly technologized artistic practice, shedding light on how non-linearity, play and generativity will become prominent in future creative media productions.
18
Qu, Zhi Ming. "Investigation and Impact of Knowledge-Based Information on Programming Languages Based on Probabilistic Models." Applied Mechanics and Materials 39 (November 2010): 436–40. http://dx.doi.org/10.4028/www.scientific.net/amm.39.436.
Full textAbstract:
In recent years, much research has been devoted to the refinement of IPv6; on the other hand, few have investigated the confusing unification of interrupts and Internet QoS. In this position paper, it demonstrates the emulation of interrupts. In order to overcome this quagmire, a novel system is presented for the intuitive unification of expert systems and massive multiplayer online role-playing games. It is concluded that erasure coding can be verified to make heterogeneous, interposable, and event-driven, which is proved to be applicable.
19
Husein, Muhammad, and Ida Bagus Gede Dwidasmara. "Design Build Finding EO as A Web-Based Marketplace Event Organizer and Venue Apps." JELIKU (Jurnal Elektronik Ilmu Komputer Udayana) 8, no. 4 (February 4, 2020): 433. http://dx.doi.org/10.24843/jlk.2020.v08.i04.p09.
Full textAbstract:
Event in Indonesia is an activity that utilizes a place or service in the implementation of these activities. Many obstacles that currently often occur when an event wants to be held either in the limited availability of information about the Event Organizer or where the event is inadequate due to limited sources. The similar information provided only display Event Organizer or Venue, but this is limited by the absence of a system that fulfills the transaction process directly. In the era of the development of science and technology as well as industry 4.0 that continues to expand, business ideas emerge that are initialized into one of the web-based marketplace application platforms that are able to promote Event Organizer and Venue also provide information and Event Organizer and Venue ordering processes for Event Users. The system, entitled Finding EO, uses the Prototyping method and its developed with PHP Programming languages.
20
DONNELLY, KEVIN, and MATTHEW FLUET. "Transactional events." Journal of Functional Programming 18, no. 5-6 (September 2008): 649–706. http://dx.doi.org/10.1017/s0956796808006916.
Full textAbstract:
AbstractConcurrent programs require high-level abstractions in order to manage complexity and enable compositional reasoning. In this paper, we introduce a novel concurrency abstraction, dubbed transactional events, which combines first-class synchronous message passing events with all-or-nothing transactions. This combination enables simple solutions to interesting problems in concurrent programming. For example, guarded synchronous receive can be implemented as an abstract transactional event, whereas in other languages it requires a non-abstract, non-modular protocol. As another example, three-way rendezvous can be implemented as an abstract transactional event, which is impossible using first-class events alone. Both solutions are easy to code and easy to reason about.The expressive power of transactional events arises from a sequencing combinator whose semantics enforces an all-or-nothing transactional property – either both of the constituent events synchronize in sequence or neither of them synchronizes. This sequencing combinator, along with a non-deterministic choice combinator, gives transactional events the compositional structure of a monad-with-plus. We provide a formal semantics for transactional events and give a detailed account of an implementation.
21
Cristiá, Maximiliano, Diego A. Hollmann, and Claudia Frydman. "A multi-target compiler for CML-DEVS." SIMULATION 95, no. 1 (April 13, 2018): 11–29. http://dx.doi.org/10.1177/0037549718765080.
Full textAbstract:
Discrete Event System Specification (DEVS) is a modular and hierarchical formalism for system modeling and simulation. DEVS models can be mathematically described; simulation is performed by tools called concrete simulators. Concerning atomic DEVS models, each concrete simulator has its own input language which is, essentially, a general-purpose programming language (such as Java or C++). Hence, once engineers have written the mathematical model, they need to manually translate it into the input language of the concrete simulator of their choice. In this paper we present a multi-target compiler for atomic DEVS models written in CML-DEVS, a mathematics-based DEVS modeling language. This multi-target compiler is able to compile a CML-DEVS model to the input languages of the PowerDEVS and DEVS-Suite concrete simulators. In this way, the CML-DEVS compiler frees engineers from the manual translation of their mathematical models. In fact, the same mathematical model can be simulated on both simulators by simply recompiling the model. The CML-DEVS multi-target compiler can be easily extended to produce code for other concrete simulators.
22
Lohstroh, Marten, Christian Menard, Soroush Bateni, and Edward A. Lee. "Toward a Lingua Franca for Deterministic Concurrent Systems." ACM Transactions on Embedded Computing Systems 20, no. 4 (June 2021): 1–27. http://dx.doi.org/10.1145/3448128.
Full textAbstract:
Many programming languages and programming frameworks focus on parallel and distributed computing. Several frameworks are based on actors, which provide a more disciplined model for concurrency than threads. The interactions between actors, however, if not constrained, admit nondeterminism. As a consequence, actor programs may exhibit unintended behaviors and are less amenable to rigorous testing. We show that nondeterminism can be handled in a number of ways, surveying dataflow dialects, process networks, synchronous-reactive models, and discrete-event models. These existing approaches, however, tend to require centralized control, pose challenges to modular system design, or introduce a single point of failure. We describe “reactors,” a new coordination model that combines ideas from several of these approaches to enable determinism while preserving much of the style of actors. Reactors promote modularity and allow for distributed execution. By using a logical model of time that can be associated with physical time, reactors also provide control over timing. Reactors also expose parallelism that can be exploited on multicore machines and in distributed configurations without compromising determinacy.
23
Sirjani, Marjan, Edward A. Lee, and Ehsan Khamespanah. "Verification of Cyberphysical Systems." Mathematics 8, no. 7 (July 2, 2020): 1068. http://dx.doi.org/10.3390/math8071068.
Full textAbstract:
The value of verification of cyberphysical systems depends on the relationship between the state of the software and the state of the physical system. This relationship can be complex because of the real-time nature and different timelines of the physical plant, the sensors and actuators, and the software that is almost always concurrent and distributed. In this paper, we study different ways to construct a transition system model for the distributed and concurrent software components of a CPS. The purpose of the transition system model is to enable model checking, an established and widely used verification technique. We describe a logical-time-based transition system model, which is commonly used for verifying programs written in synchronous languages, and derive the conditions under which such a model faithfully reflects physical states. When these conditions are not met (a common situation), a finer-grained event-based transition system model may be required. We propose an approach for formal verification of cyberphysical systems using Lingua Franca, a language designed for programming cyberphysical systems, and Rebeca, an actor-based language designed for model checking distributed event-driven systems. We focus on the cyber part and model a faithful interface to the physical part. Our method relies on the assumption that the alignment of different timelines during the execution of the system is the responsibility of the underlying platforms. We make those assumptions explicit and clear.
24
Mirroshandel, S. A., and G. Ghassem-Sani. "Towards Unsupervised Learning of Temporal Relations between Events." Journal of Artificial Intelligence Research 45 (September 26, 2012): 125–63. http://dx.doi.org/10.1613/jair.3693.
Full textAbstract:
Automatic extraction of temporal relations between event pairs is an important task for several natural language processing applications such as Question Answering, Information Extraction, and Summarization. Since most existing methods are supervised and require large corpora, which for many languages do not exist, we have concentrated our efforts to reduce the need for annotated data as much as possible. This paper presents two different algorithms towards this goal. The first algorithm is a weakly supervised machine learning approach for classification of temporal relations between events. In the first stage, the algorithm learns a general classifier from an annotated corpus. Then, inspired by the hypothesis of "one type of temporal relation per discourse'', it extracts useful information from a cluster of topically related documents. We show that by combining the global information of such a cluster with local decisions of a general classifier, a bootstrapping cross-document classifier can be built to extract temporal relations between events. Our experiments show that without any additional annotated data, the accuracy of the proposed algorithm is higher than that of several previous successful systems. The second proposed method for temporal relation extraction is based on the expectation maximization (EM) algorithm. Within EM, we used different techniques such as a greedy best-first search and integer linear programming for temporal inconsistency removal. We think that the experimental results of our EM based algorithm, as a first step toward a fully unsupervised temporal relation extraction method, is encouraging.
25
Failmezger, Henrik, Ezgi Dursun, Sebastian Dümcke, Max Endele, Don Poron, Timm Schroeder, Anne Krug, and Achim Tresch. "Clustering of samples with a tree-shaped dependence structure, with an application to microscopic time lapse imaging." Bioinformatics 35, no. 13 (November 19, 2018): 2291–99. http://dx.doi.org/10.1093/bioinformatics/bty939.
Full textAbstract:
Abstract Motivation Recent imaging technologies allow for high-throughput tracking of cells as they migrate, divide, express fluorescent markers and change their morphology. The interpretation of these data requires unbiased, efficient statistical methods that model the dynamics of cell phenotypes. Results We introduce treeHFM, a probabilistic model which generalizes the theory of hidden Markov models to tree structured data. While accounting for the entire genealogy of a cell, treeHFM categorizes cells according to their primary phenotypic features. It models all relevant events in a cell’s life, including cell division, and thereby enables the analysis of event order and cell fate heterogeneity. Simulations show higher accuracy in predicting correct state labels when modeling the more complex, tree-shaped dependency of samples over standard HMM modeling. Applying treeHFM to time lapse images of hematopoietic progenitor cell differentiation, we demonstrate that progenitor cells undergo a well-ordered sequence of differentiation events. Availability and implementation The treeHFM is implemented in C++. We provide wrapper functions for the programming languages R (CRAN package, https://CRAN.R-project.org/package=treeHFM) and Matlab (available at Mathworks Central, http://se.mathworks.com/matlabcentral/fileexchange/57575-treehfml). Supplementary information Supplementary data are available at Bioinformatics online.
26
Droste, Manfred, and Rüdiger Gübel. "Universal domains and the amalgamation property." Mathematical Structures in Computer Science 3, no. 2 (June 1993): 137–59. http://dx.doi.org/10.1017/s0960129500000177.
Full textAbstract:
In the theory of denotational semantics of programming languages, several authors have constructed various kinds of universal domains. We present here a categorical generalization of a well-known result in model theory, which we use to characterize large classes of reasonable categories that contain universal homogeneous objects. The existence of such objects is characterized by the condition that the finite objects in the category satisfy the amalgamation property. We derive from this the existence and uniqueness of universal homogeneous domains for several categories of bifinite domains, with embedding-projection-pairs as morphisms. We also obtain universal homogeneous objects for various categories of stable bifinite domains. In contrast, several categories of event domains and concrete domains and the category of all coherent Scott-domains do not contain universal homogeneous objects. Finally, we show that all our constructions can be performed effectively.
27
Yuniva, Ika, Andriansah, and M. Seprian Alfath Arkab. "Perancangan Web Jasa Penyewaan Sound System Pada Eman Sounds." Jurnal Jaring SainTek 2, no. 1 (June 15, 2020): 33–40. http://dx.doi.org/10.31599/jaring-saintek.v2i1.63.
Full textAbstract:
Eman Sounds is a business venture in the field of sound system rental services. The Eman sounds does not currently have a website application. The leasing service transaction system is still done conventionally, where if anyone wants to rent a sound system for a wedding or other official event can come directly to the Eman Sounds to see and rent it. For transaction reports sound system rental services are still recorded with paper so as to allow for data loss and errors in recording transactions. The purpose of this study is that the author will design a web sound system rental service for Eman Sounds so that it is expected to simplify the process of leasing transactions and making rental reports. The author uses the system development method, namely the waterfall model for this study. The use of PHP and HTML programming languages the author uses to create web rental services and MYSQL as the database. The results of this study are expected that with a web design sound system rental service can help Eman Sounds in the process of managing rental transactions and reports.
28
Shodiq, Muchamad, Kodrat Iman Satoto, and Rinta Kridalukmana. "SIMBES, Aplikasi Manajemen Beasiswa di Universitas Diponegoro Berbasis Framework Code Igniter dan MySQL." Jurnal Teknologi dan Sistem Komputer 1, no. 4 (October 30, 2013): 86–92. http://dx.doi.org/10.14710/jtsiskom.1.4.2013.86-92.
Full textAbstract:
Scholarship is a very important need for the students to be able to continue their education, especially for disadvantaged groups as well as achievement. Diponegoro University as one of the State institutions strive to provide assistance in the form of scholarships for students to be able to carry out their studies. However, the distribution of these scholarships often have many constraints experienced by students as time is too sudden, and difficulties in completing other requirements. Application Scholarship Information Systems, University of Diponegoro is one way to overcome the distribution of scholarships at the University of Diponegoro. This application helps in increasing the speed of Diponegoro University and management in the distribution of scholarships to students.The stage in this application uses several stages of literature and guidance, data collection and analysis (interviews, observations and information files), design, manufacture of system / application and final implementation commonly referred to as the waterfall method. This method is very appropriate in this study because it has applications like workflow that allows designers to evaluate the application without having to change from the bottom. While the design of the application using UML modeling.This application is based on the Code Igniter framework which uses MVC method (Model, View, Controller) with every event organized by function application specified in the controller. In the testing phase, the application was tested in the scope of its functions. As a result, every function can be run smoothly and Information Systems Scholarship applications can be implemented. Information Systems Scholarship applications can run smoothly in the Code Igniter framework along with its functions. However, these applications are not fully using the PHP programming language in its function, there are languages that work client side Javascript that helps in performing certain functions. It is recommended not to disable javascript in a user's browser or will affect the application does not work properly.
29
Pulido-Prieto, Oscar, and Ulises Juárez-Martínez. "A Model for Naturalistic Programming with Implementation." Applied Sciences 9, no. 18 (September 19, 2019): 3936. http://dx.doi.org/10.3390/app9183936.
Full textAbstract:
While the use of natural language for software development has been proposed since the 1960s, it was limited by the inherent ambiguity of natural languages, which people resolve using reasoning in a text or conversation. Programming languages are formal general-purpose or domain-specific alternatives based on mathematical formalism and which are at a remove from natural language. Over the years, various authors have presented studies in which they attempted to use a subset of the English language for solving particular problems. Each author approached the problem by covering particular domains, rather than focusing on describing general elements that would help other authors develop general-purpose languages, instead focusing even more on domain-specific languages. The identification of common elements in these studies reveals characteristics that enable the design and implementation of general-purpose naturalistic languages, which requires the establishment of a programming model. This article presents a conceptual model which describes the elements required for designing general-purpose programming languages and which integrates abstraction, temporal elements and indirect references into its grammar. Moreover, as its grammar resembles natural language, thus reducing the gap between problem and solution domains, a naturalistic language prototype is presented, as are three test scenarios which demonstrate its characteristics.
30
Mergili, M., J. Krenn, and H. J. Chu. "r.randomwalk v1, a multi-functional conceptual tool for mass movement routing." Geoscientific Model Development 8, no. 12 (December 16, 2015): 4027–43. http://dx.doi.org/10.5194/gmd-8-4027-2015.
Full textAbstract:
Abstract. We introduce r.randomwalk, a flexible and multi-functional open-source tool for backward and forward analyses of mass movement propagation. r.randomwalk builds on GRASS GIS (Geographic Resources Analysis Support System – Geographic Information System), the R software for statistical computing and the programming languages Python and C. Using constrained random walks, mass points are routed from defined release pixels of one to many mass movements through a digital elevation model until a defined break criterion is reached. Compared to existing tools, the major innovative features of r.randomwalk are (i) multiple break criteria can be combined to compute an impact indicator score; (ii) the uncertainties of break criteria can be included by performing multiple parallel computations with randomized parameter sets, resulting in an impact indicator index in the range 0–1; (iii) built-in functions for validation and visualization of the results are provided; (iv) observed landslides can be back analysed to derive the density distribution of the observed angles of reach. This distribution can be employed to compute impact probabilities for each pixel. Further, impact indicator scores and probabilities can be combined with release indicator scores or probabilities, and with exposure indicator scores. We demonstrate the key functionalities of r.randomwalk for (i) a single event, the Acheron rock avalanche in New Zealand; (ii) landslides in a 61.5 km2 study area in the Kao Ping Watershed, Taiwan; and (iii) lake outburst floods in a 2106 km2 area in the Gunt Valley, Tajikistan.
31
Mergili, M., J. Krenn, and H. J. Chu. "r.randomwalk v1.0, a multi-functional conceptual tool for mass movement routing." Geoscientific Model Development Discussions 8, no. 9 (September 25, 2015): 8193–237. http://dx.doi.org/10.5194/gmdd-8-8193-2015.
Full textAbstract:
Abstract. We introduce r.randomwalk, a flexible and multi-functional open source tool for backward- and forward-analyses of mass movement propagation. r.randomwalk builds on GRASS GIS, the R software for statistical computing and the programming languages Python and C. Using constrained random walks, mass points are routed from defined release pixels of one to many mass movements through a digital elevation model until a defined break criterion is reached. Compared to existing tools, the major innovative features of r.randomwalk are: (i) multiple break criteria can be combined to compute an impact indicator score, (ii) the uncertainties of break criteria can be included by performing multiple parallel computations with randomized parameter settings, resulting in an impact indicator index in the range 0–1, (iii) built-in functions for validation and visualization of the results are provided, (iv) observed landslides can be back-analyzed to derive the density distribution of the observed angles of reach. This distribution can be employed to compute impact probabilities for each pixel. Further, impact indicator scores and probabilities can be combined with release indicator scores or probabilities, and with exposure indicator scores. We demonstrate the key functionalities of r.randomwalk (i) for a single event, the Acheron Rock Avalanche in New Zealand, (ii) for landslides in a 61.5 km2 study area in the Kao Ping Watershed, Taiwan; and (iii) for lake outburst floods in a 2106 km2 area in the Gunt Valley, Tajikistan.
32
DYLUS, SANDRA, JAN CHRISTIANSEN, and FINN TEEGEN. "Implementing a Library for Probabilistic Programming Using Non-strict Non-determinism." Theory and Practice of Logic Programming 20, no. 1 (July 2, 2019): 147–75. http://dx.doi.org/10.1017/s1471068419000085.
Full textAbstract:
AbstractThis paper presentsPFLP, a library for probabilistic programming in the functional logic programming language Curry. It demonstrates how the concepts of a functional logic programming language support the implementation of a library for probabilistic programming. In fact, the paradigms of functional logic and probabilistic programming are closely connected. That is, language characteristics from one area exist in the other and vice versa. For example, the concepts of non-deterministic choice and call-time choice as known from functional logic programming are related to and coincide with stochastic memoization and probabilistic choice in probabilistic programming, respectively. We will further see that an implementation based on the concepts of functional logic programming can have benefits with respect to performance compared to a standard list-based implementation and can even compete with full-blown probabilistic programming languages, which we illustrate by several benchmarks.
33
Sulistiani, Lisan, and Oscar Karnalim. "An Embedding Technique for Language-Independent Lecturer-Oriented Program Visualization." EMITTER International Journal of Engineering Technology 6, no. 1 (July 10, 2018): 92–104. http://dx.doi.org/10.24003/emitter.v6i1.234.
Full textAbstract:
Nowadays, programming is a promising skill to be learned; the demand of programmer is increased. To align with such trend, several Program Visualization (PV) tools have been developed. Using such tool, user can learn how a particular program works through interactive and descriptive visualization. However, most of the tools are language-dependent: they use either language-dependent debugger or code to generate visualization. Such dependency may become a problem when a program written in new programming language is incorporated. Therefore, this paper proposes an embedding technique to handle given issue. To incorporate new programming language, it only needs five language-dependent features to be set. In general, our proposed technique works in threefold: embedding some statements to target program, generating visualization states by running the program with console commands, and visualizing given program based on generated visualization states. According to our evaluation, proposed technique is able to incorporate program written in any programming languages as long as those languages provide required language-dependent features. Further, it is practical to be used since it still have the benefits of conventional PV even though it is designed as a language-independent PV.
34
Srbljić, Siniša, Dejan Škvorc, and Daniel Skrobo. "Programming Language Design for Event-Driven Service Composition." Automatika 51, no. 4 (January 2010): 374–86. http://dx.doi.org/10.1080/00051144.2010.11828393.
Full text
35
Yu, Liu. "Research on General Programming Environment Technology Based on Web." MATEC Web of Conferences 232 (2018): 01040. http://dx.doi.org/10.1051/matecconf/201823201040.
Full textAbstract:
As the MOOC develops, many users have begun to gradually like and get used to programming learning on the MOOC platform, so virtual online experiments have become a hot spot in the online programming education industry, which is also known as online IDE or online programming environment. Compared with the traditional programming environment, the online programming environment does not require a complicated establishment of local environment, making it easy to be used. At the same time, the online programming environment can also be integrated into the MOOC for learning, and can also be combined with OJ for evaluation. However, the existing online programming environment usually only supports few programming languages, such as C language and Java language. Even some online platforms only have the online compiling function with one language. Based on the above phenomena, this paper will propose a general online programming solution. And based on the idea, a platform that supports multi-language online compiling function is built through simple code writing and the construction of server environment.
36
Husain, Hariati, and Evie Adriani. "Sistem Informasi Geografis Penyebaran Kutu Kebul pada Tanaman Cabai Berbasis Android di Provinsi Gorontalo." Jurnal Teknologi Informasi Indonesia (JTII) 5, no. 2 (November 23, 2020): 36–43. http://dx.doi.org/10.30869/jtii.v5i2.654.
Full textAbstract:
Production of fresh cayenne pepper with stalks in 2014 in Prov. Gorontalo amounted to 117,719 Quintal. Compared to 2013, there was a decrease in the production of 10,105 Quintal (-7.91 percent). This decrease was due to a decrease in productivity of 3.54 Quintal per hectare (-6.36 percent) and also a decrease in the harvest area of 38 hectares (-1.66 percent) compared to 2013. In addition to the area of low harvest, there are some obstacles, especially pest attacks and diseases that are always the main problem in the event of crop failure. Pests that attack cayenne pepper plants are whitefly (Bemisia tabacci). Thus, that needs to be done in tackling the pests of whitefly. The study began with a major survey covering data collection and information, field studies, and observations on the attack of whitefly pests on cayenne pepper plants, sampling of whitefly pests, and observed morphine. All quantitative data is inputted into geographic information systems (GIS) as attribute data in the GIS. Information search and access user information and communication technology through high mobility media such as smartphones. Today's thriving smartphones are smartphones with android operating systems. Android smartphones besides having high mobility, also have very useful features such as google maps and GPS. Google maps and GPS features can collaborate in an android app program creation. Application program creation is designed using android and PHP programming languages collaborated with MySQL databases as data container media. The research aims to create a geographic information system that can help chili farmers and agricultural practitioners to be able to detect early the location of the spread of whitefly (B. tabaci) before there is a decrease in the production and growth of chili pepper crops. The study also aims to analyze and determine the zoning of the spread of whitefly pests on cayenne pepper plants using geographic information systems.
37
O'Dowd, Mike. "MEX, a programming language that supports discrete event simulation." Microprocessing and Microprogramming 27, no. 1-5 (August 1989): 215–20. http://dx.doi.org/10.1016/0165-6074(89)90049-5.
Full text
38
Vanags, Mikus, and Rudite Cevere. "Type Safe Metadata Combining." Computer and Information Science 10, no. 2 (April 30, 2017): 97. http://dx.doi.org/10.5539/cis.v10n2p97.
Full textAbstract:
Type safety is an important property of any type system. Modern programming languages support different mechanisms to work in type safe manner, e.g., properties, methods, events, attributes (annotations) and other structures. Some programming languages allow access to metadata: type information, type member information and information about applied attributes. But none of the existing mainstream programming languages which support reflection provides fully type safe metadata combining mechanism built in the programming language. Combining of metadata means a class member metadata combining with data, type metadata and constraints. Existing solutions provide no or limited type safe metadata combining mechanism; they are complex and processed at runtime, which by definition is not built-in type-safe metadata combining. Problem can be solved by introducing syntax and methods for type safe metadata combining so that, metadata could be processed at compile time in a fully type safe way. Common metadata combining use cases are data abstraction layer creation and database querying.
39
Nofre, David. "The Politics of Early Programming Languages." Historical Studies in the Natural Sciences 51, no. 3 (June 1, 2021): 379–413. http://dx.doi.org/10.1525/hsns.2021.51.3.379.
Full textAbstract:
There probably has never been such a controversial programming language as Algol. In the early 1960s the disciplinary success of the so-called Algol project in helping to forge the discipline of computer science was not matched by a significant adoption of the Algol language, in any of its three versions. This contrast is even more striking when considering the contemporary success of IBM’s Fortran, a language that, like Algol, was also conceived for scientific computation, but unlike Algol, initially only available for IBM computers. Through extensive archival research, this article shows how the relentless pursuit of a still better language that came to dominate the agenda of the Algol project brought to the fore the tension between the research-driven dimension of the project and the goal of developing a reliable programming language. Such a strong research-oriented agenda increased IBM’s doubts about a project that the firm already felt little urge to support. Yet IBM did not want to appear as obstructing the development of either Algol or Cobol, even if these “common languages” posed a clear risk to the firm’s marketing model. The US Department of Defense’s endorsement of Cobol and the rising popularity of Algol in Europe convinced IBM to push for the use of Fortran in Western Europe in order to protect the domestic market. IBM’s action in support of Fortran reminds us of the power imbalances that have shaped computer science.
40
Ryapolov, Vladimir I., and Evgeniy Yu Voronkin. "DEVELOPMENT OF A DATABASE FOR HOLDING SCIENTIFIC EVENTS OF THE UNIVERSITY." Interexpo GEO-Siberia 7, no. 1 (July 8, 2020): 174–80. http://dx.doi.org/10.33764/2618-981x-2020-7-1-174-180.
Full textAbstract:
The article discusses the implementation of the server side of the information platform for organizing scientific and methodological events, which includes the creation of a database of events and a system for registering participants for methodological events. The implementation of the server part will help, in this case, automate the system of collecting data about participants for the organizers, as well as allow participants to quickly monitor the status of their submitted applications and articles. The server part of the development of an information platform for organizing scientific and methodological events belongs to the direction of backend programming and includes the study of the scripting language PHP, the free relational database management system MySQL, the content management system (CMS) Drupal, as well as the technologies for interaction between the listed systems and programming languages.
41
Amela, Ramon, Cristian Ramon-Cortes, Jorge Ejarque, Javier Conejero, and Rosa M. Badia. "Executing linear algebra kernels in heterogeneous distributed infrastructures with PyCOMPSs." Oil & Gas Science and Technology – Revue d’IFP Energies nouvelles 73 (2018): 47. http://dx.doi.org/10.2516/ogst/2018047.
Full textAbstract:
Python is a popular programming language due to the simplicity of its syntax, while still achieving a good performance even being an interpreted language. The adoption from multiple scientific communities has evolved in the emergence of a large number of libraries and modules, which has helped to put Python on the top of the list of the programming languages [1]. Task-based programming has been proposed in the recent years as an alternative parallel programming model. PyCOMPSs follows such approach for Python, and this paper presents its extensions to combine task-based parallelism and thread-level parallelism. Also, we present how PyCOMPSs has been adapted to support heterogeneous architectures, including Xeon Phi and GPUs. Results obtained with linear algebra benchmarks demonstrate that significant performance can be obtained with a few lines of Python.
42
Valverde, Sergi, and Ricard V. Solé. "Punctuated equilibrium in the large-scale evolution of programming languages." Journal of The Royal Society Interface 12, no. 107 (June 2015): 20150249. http://dx.doi.org/10.1098/rsif.2015.0249.
Full textAbstract:
The analogies and differences between biological and cultural evolution have been explored by evolutionary biologists, historians, engineers and linguists alike. Two well-known domains of cultural change are language and technology. Both share some traits relating the evolution of species, but technological change is very difficult to study. A major challenge in our way towards a scientific theory of technological evolution is how to properly define evolutionary trees or clades and how to weight the role played by horizontal transfer of information. Here, we study the large-scale historical development of programming languages, which have deeply marked social and technological advances in the last half century. We analyse their historical connections using network theory and reconstructed phylogenetic networks. Using both data analysis and network modelling, it is shown that their evolution is highly uneven, marked by innovation events where new languages are created out of improved combinations of different structural components belonging to previous languages. These radiation events occur in a bursty pattern and are tied to novel technological and social niches. The method can be extrapolated to other systems and consistently captures the major classes of languages and the widespread horizontal design exchanges, revealing a punctuated evolutionary path.
43
CALIMERI, FRANCESCO, WOLFGANG FABER, MARTIN GEBSER, GIOVAMBATTISTA IANNI, ROLAND KAMINSKI, THOMAS KRENNWALLNER, NICOLA LEONE, MARCO MARATEA, FRANCESCO RICCA, and TORSTEN SCHAUB. "ASP-Core-2 Input Language Format." Theory and Practice of Logic Programming 20, no. 2 (December 20, 2019): 294–309. http://dx.doi.org/10.1017/s1471068419000450.
Full textAbstract:
AbstractStandardization of solver input languages has been a main driver for the growth of several areas within knowledge representation and reasoning, fostering the exploitation in actual applications. In this document, we present the ASP-CORE-2 standard input language for Answer Set Programming, which has been adopted in ASP Competition events since 2013.
44
Susko, Alexander Q., and Zachary T. Brym. "An Introduction to R Statistical Computing for Horticultural Science." HortTechnology 26, no. 5 (October 2016): 588–91. http://dx.doi.org/10.21273/horttech03339-16.
Full textAbstract:
We present the format for a workshop on introductory computer programming, which was held at the 2015 American Society for Horticultural Science (ASHS) Annual Conference in New Orleans, LA. The main workshop objective was to familiarize attendees with basic computer programming, including data structures, data management, and data analysis. The workshop used the general programming language R, though the concepts and principles presented are transferable across programming languages. Given the increased importance of statistical analysis in the agricultural sciences, the workshop was well attended. Participants appreciated the opportunity to improve their computational literacy and supported follow-up workshops like this at future ASHS events. We have released the presentation and the companion R script online.
45
Liu, Yu Bin, and Xin Fa Dong. "Research on the IDE of Visual Programming Language." Advanced Materials Research 219-220 (March 2011): 140–43. http://dx.doi.org/10.4028/www.scientific.net/amr.219-220.140.
Full textAbstract:
This paper proposes a new method for visual programming. Make full use of visual graph and visual studio, which are popular environment for visual interface development, the author developed some controls with some properties and events in visual graph, and then re-edit them in visual studio as the basic controls. With these basic controls people can do their visual programming without inputting work of text codes. Even a common developer can gain the software what they need by using some graphical component like building blocks. This may greatly improve development efficiency and avoid code rewriting greatly.
46
McPherson, Andrew, and Koray Tahıroğlu. "Idiomatic Patterns and Aesthetic Influence in Computer Music Languages." Organised Sound 25, no. 1 (March 4, 2020): 53–63. http://dx.doi.org/10.1017/s1355771819000463.
Full textAbstract:
It is widely accepted that acoustic and digital musical instruments shape the cognitive processes of the performer on both embodied and conceptual levels, ultimately influencing the structure and aesthetics of the resulting performance. In this article we examine the ways in which computer music languages might similarly influence the aesthetic decisions of the digital music practitioner, even when those languages are designed for generality and theoretically capable of implementing any sound-producing process. We examine the basis for querying the non-neutrality of tools with a particular focus on the concept of idiomaticity: patterns of instruments or languages which are particularly easy or natural to execute in comparison to others. We then present correspondence with the developers of several major music programming languages and a survey of digital musical instrument creators examining the relationship between idiomatic patterns of the language and the characteristics of the resulting instruments and pieces. In an open-ended creative domain, asserting causal relationships is difficult and potentially inappropriate, but we find a complex interplay between language, instrument, piece and performance that suggests that the creator of the music programming language should be considered one party to a creative conversation that occurs each time a new instrument is designed.
47
McConnell, B. S. "Algorithmic Communication with Extraterrestrial Intelligence." Symposium - International Astronomical Union 213 (2004): 445–50. http://dx.doi.org/10.1017/s0074180900193696.
Full textAbstract:
ACETI (algorithmic communication with extraterrestrial intelligence) builds upon mathematical languages to create a general purpose programming language. While the underlying framework may be quite simple, the programs derived from even a small instruction set, when run on a sufficiently fast computing substrate, may interact with their users in real-time and may exhibit complex behavior.
48
HERMENEGILDO, M. V., F. BUENO, M. CARRO, P. LÓPEZ-GARCÍA, E. MERA, J. F. MORALES, and G. PUEBLA. "An overview of Ciao and its design philosophy." Theory and Practice of Logic Programming 12, no. 1-2 (December 30, 2011): 219–52. http://dx.doi.org/10.1017/s1471068411000457.
Full textAbstract:
AbstractWe provide an overall description of the Ciao multiparadigm programming system emphasizing some of the novel aspects and motivations behind its design and implementation. An important aspect of Ciao is that, in addition to supporting logic programming (and, in particular, Prolog), it provides the programmer with a large number of useful features from different programming paradigms and styles and that the use of each of these features (including those of Prolog) can be turned on and off at will for each program module. Thus, a given module may be using, e.g., higher order functions and constraints, while another module may be using assignment, predicates, Prolog meta-programming, and concurrency. Furthermore, the language is designed to be extensible in a simple and modular way. Another important aspect of Ciao is its programming environment, which provides a powerful preprocessor (with an associated assertion language) capable of statically finding non-trivial bugs, verifying that programs comply with specifications, and performing many types of optimizations (including automatic parallelization). Such optimizations produce code that is highly competitive with other dynamic languages or, with the (experimental) optimizing compiler, even that of static languages, all while retaining the flexibility and interactive development of a dynamic language. This compilation architecture supports modularity and separate compilation throughout. The environment also includes a powerful autodocumenter and a unit testing framework, both closely integrated with the assertion system. The paper provides an informal overview of the language and program development environment. It aims at illustrating the design philosophy rather than at being exhaustive, which would be impossible in a single journal paper, pointing instead to previous Ciao literature.
49
Bryant, Barrett, Jeff Gray, Marjan Mernik, Peter Clarke, Robert France, and Gabor Karsai. "Challenges and directions in formalizing the semantics of modeling languages." Computer Science and Information Systems 8, no. 2 (2011): 225–53. http://dx.doi.org/10.2298/csis110114012b.
Full textAbstract:
Developing software from models is a growing practice and there exist many model-based tools (e.g., editors, interpreters, debuggers, and simulators) for supporting model-driven engineering. Even though these tools facilitate the automation of software engineering tasks and activities, such tools are typically engineered manually. However, many of these tools have a common semantic foundation centered around an underlying modeling language, which would make it possible to automate their development if the modeling language specification were formalized. Even though there has been much work in formalizing programming languages, with many successful tools constructed using such formalisms, there has been little work in formalizing modeling languages for the purpose of automation. This paper discusses possible semantics-based approaches for the formalization of modeling languages and describes how this formalism may be used to automate the construction of modeling tools.
50
VENNEKENS, JOOST, MARC DENECKER, and MAURICE BRUYNOOGHE. "CP-logic: A language of causal probabilistic events and its relation to logic programming." Theory and Practice of Logic Programming 9, no. 3 (May 2009): 245–308. http://dx.doi.org/10.1017/s1471068409003767.
Full textAbstract:
AbstractThis paper develops a logical language for representing probabilistic causal laws. Our interest in such a language is two-fold. First, it can be motivated as a fundamental study of the representation of causal knowledge. Causality has an inherent dynamic aspect, which has been studied at the semantical level by Shafer in his framework of probability trees. In such a dynamic context, where the evolution of a domain over time is considered, the idea of a causal law as something which guides this evolution is quite natural. In our formalization, a set of probabilistic causal laws can be used to represent a class of probability trees in a concise, flexible and modular way. In this way, our work extends Shafer's by offering a convenient logical representation for his semantical objects. Second, this language also has relevance for the area of probabilistic logic programming. In particular, we prove that the formal semantics of a theory in our language can be equivalently defined as a probability distribution over the well-founded models of certain logic programs, rendering it formally quite similar to existing languages such as ICL or PRISM. Because we can motivate and explain our language in a completely self-contained way as a representation of probabilistic causal laws, this provides a new way of explaining the intuitions behind such probabilistic logic programs: we can say precisely which knowledge such a program expresses, in terms that are equally understandable by a non-logician. Moreover, we also obtain an additional piece of knowledge representation methodology for probabilistic logic programs, by showing how they can express probabilistic causal laws.