Relevant bibliographies by topics / Programming Languages, Event

Contents

  1. Journal articles
  2. Dissertations / Theses
  3. Books
  4. Book chapters
  5. Conference papers

Academic literature on the topic 'Programming Languages, Event'

Author: Grafiati
Published: 4 June 2021
Last updated: 1 February 2022

Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources 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.

Journal articles on the topic "Programming Languages, Event"

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
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
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
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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).
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
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 text
Abstract:
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.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Programming Languages, Event"

1

Malakuti, Somayeh. "An Overview of Language Support for Modular Event-driven Programming." Saechsische Landesbibliothek- Staats- und Universitaetsbibliothek Dresden, 2015. http://nbn-resolving.de/urn:nbn:de:bsz:14-qucosa-175990.

Full text
Abstract:
Nowadays, event processing is becoming the backbone of many applications. Therefore, it is necessary to provide suitable abstractions to properly modularize the concerns that appear in event-driven applications. We identify four categories of languages that support event-driven programming, and identify their shortcomings in achieving modularity in the implementation of applications. We propose gummy modules and their implementation in the GummyJ language as a solution. Gummy modules have well-defined event-based interfaces, and can have a primitive or a composite structure. Composite gummy modules are means to group a set of correlated event processing concerns and restrict the visibility of events among them. We provide an example usage of gummy modules, and discuss their event processing semantics.
APA, Harvard, Vancouver, ISO, and other styles
2

El-Kays, Ahmad Ziad. "Implementing event handlers in a database programming language." Thesis, McGill University, 1996. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=23884.

Full text
Abstract:
This thesis introduces active database concepts to a relational database system. Event handlers are introduced as user defined procedures. An event is the procedure call by the system, triggered in our case by an update statement.
Event handlers for the Relix (Relational database on UNIX) update statement have been implemented. These event handlers are of two types: the first type is that which runs before an update statement. The second type runs after an update statement. Also, event handlers have states. An event handler can be either active or inactive. Event handlers are executed when they are in the active state.
Event handlers have the property of being "one-to-many", i.e. for a single event more than one event handler can be defined. Another property is non-determinism, i.e., event handlers are executed with no pre-specified order.
In this thesis we present the design and implementation of event handlers in Relix. The mechanism that we introduced in Relix is equivalent to the EA model.
APA, Harvard, Vancouver, ISO, and other styles
3

Kent, Stuart John Harding. "Modelling events from natural language." Thesis, Imperial College London, 1993. http://kar.kent.ac.uk/21146/.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Sun, Weizhong 1975. "Updates and events in a nested relational programming language." Thesis, McGill University, 2000. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=33448.

Full text
Abstract:
This thesis documents the design and implementation of Updates and Event Handlers in a relational database programming language. Update operations are implemented in the nested relational model and Event Handlers transform the database system from passive to active.
The update operation allows the user to change values of specified attributes in certain tuples. These attributes can be selected by a "using" clause which uses a relational algebra operation to select tuples from the relation we want to update. We can also use updates to add or delete some tuples to or from the relation. The nested update in nested relations will also be presented.
Event handlers are introduced as procedures, invoked by events which are system generated procedure calls. We implement the event handler based on computation---the procedural abstraction facility of the database programming language.
An update statement can invoke multiple event handlers. Event handlers may contain update statements which in turn invoke other event handlers. This introduces cascading event handlers. We will present the combination of update and event handler algorithm by which the update; operation is coupled with event handler closely and neatly, and the cascading event handler is handled by the system's recursive execution.
In this thesis, we provide the user a uniform syntax to update both flat relations and nested relations. The unification of computation and procedure leads to a simpler language. More over, the explicitness and intuitiveness of the definition and implementation of both event and event handler are under substantial considerations.
APA, Harvard, Vancouver, ISO, and other styles
5

Fabbri, Francesco. "Engineering Concurrent and Event-driven Web Apps: An Agent-Oriented Approach based on the simpAL Language." Master's thesis, Alma Mater Studiorum - Università di Bologna, 2012. http://amslaurea.unibo.it/4795/.

Full text
Abstract:
Web is constantly evolving, thanks to the 2.0 transition, HTML5 new features and the coming of cloud-computing, the gap between Web and traditional desktop applications is tailing off. Web-apps are more and more widespread and bring several benefits compared to traditional ones. On the other hand reference technologies, JavaScript primarly, are not keeping pace, so a paradim shift is taking place in Web programming, and so many new languages and technologies are coming out. First objective of this thesis is to survey the reference and state-of-art technologies for client-side Web programming focusing in particular on what concerns concurrency and asynchronous programming. Taking into account the problems that affect existing technologies, we finally design simpAL-web, an innovative approach to tackle Web-apps development, based on the Agent-oriented programming abstraction and the simpAL language. == Versione in italiano: Il Web è in continua evoluzione, grazie alla transizione verso il 2.0, alle nuove funzionalità introdotte con HTML5 ed all’avvento del cloud-computing, il divario tra le applicazioni Web e quelle desktop tradizionali va assottigliandosi. Le Web-apps sono sempre più diffuse e presentano diversi vantaggi rispetto a quelle tradizionali. D’altra parte le tecnologie di riferimento, JavaScript in primis, non stanno tenendo il passo, motivo per cui la programmazione Web sta andando incontro ad un cambio di paradigma e nuovi linguaggi e tecnologie stanno spuntando sempre più numerosi. Primo obiettivo di questa tesi è di passare al vaglio le tecnologie di riferimento ed allo stato dell’arte per quel che riguarda la programmmazione Web client-side, porgendo particolare attenzione agli aspetti inerenti la concorrenza e la programmazione asincrona. Considerando i principali problemi di cui soffrono le attuali tecnologie passeremo infine alla progettazione di simpAL-web, un approccio innovativo con cui affrontare lo sviluppo di Web-apps basato sulla programmazione orientata agli Agenti e sul linguaggio simpAL.
APA, Harvard, Vancouver, ISO, and other styles
6

Gruer, Juan Pablo. "Eléments de synchronisation pour un langage temps-réel de commande de procédés." Mulhouse, 1989. http://www.theses.fr/1989MULH0105.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Rafael, João Pedro Maia. "A programming language for parallel event-driven development." Master's thesis, 2013. http://hdl.handle.net/10316/35550.

Full text
Abstract:
Dissertação de Mestrado em Engenharia Informática apresentada à Faculdade de Ciências e Tecnologia da Universidade de Coimbra
Recently, event-oriented programming frameworks have surfaced as a solution to highly scalable network applications. This model as been adopted under many languages resulting in frameworks such as Node.js, Gevent and EventMachine. These frameworks are capable of handling many concurrent requests by using asynchronous IO. However, in order to make use all available cores, parallelism is exploited by creating multiple instances of the same application. Under this solution instances don’t share memory making synchronization mechanisms required. The same problem applies when using the actor model for concurrency. The EVE framework provides support for event-oriented programming under a shared-memory model. It encompasses the EVE language definition, its compiler and a runtime system capable of executing the resulting applications. Using our model, the programmer divides the application logic into tasks and each task indicates what variables it can access. The runtime schedules compatible tasks to multiple cores using a work-stealing algorithm for load balancing. In this work, we present a formal description of the language and it’s runtime, including their operational semantics. Our benchmarks indicate that our solution delivers the best performance on IO heavy problems when compared to existing of-the-shelf solutions and performance comparable to the state-of-the-art architectures for CPU-bounded applications.
APA, Harvard, Vancouver, ISO, and other styles
8

HSU, KUO-WEI, and 徐國維. "An Event-driven Programming Extension of Conditional Expression in C Language." Thesis, 2019. http://ndltd.ncl.edu.tw/handle/3bh54w.

Full text
Abstract:
碩士
國立中央大學
資訊工程學系
107
Now a day, most of programs having UI interfaces. Whether it is a website program or an operating system, the process of the programs is determined by the user's operating. So that, the interaction between the program and the user is more and more important. The design of such programs is often using event-driven design. Event-driven programming is a common programming paradigm in which the flow of program is determined by the event such as user motions or messages from other programs. How difficult it is to design the event-driven programs is also depending on the programming language. Programming languages like C#, JAVA, PYTHON, etc., are easier to design event-driven programs because of the supporting of language itself. However, one of widely using language: C language, because of the lack of language-based support, can only design event-driven programs by the experience from designers. This research will present a tool which is called “C Event Dispatcher”(CED) to assist programmers in writing event-driven programs in C language. The feature of CED tool is that it use different way to trigger the event handler. Without using timeout and signal, it use conditional expression to trigger the handler, giving user more flexibility to design event-driven program. User can use the mechanism of conditional expression to monitor a event variable, calling the event handler depending on the condition of the event variable. The CED tool also support the publish–subscribe pattern, increasing the flexibility of event-driven architecture and the maintainability of the code. The finite-state machine built by CED tool can dynamically decrease and increase the states in the finite-state machine. This advantage is suitable for using on the embedded system. It can make the embedded system more flexible and maintainable.
APA, Harvard, Vancouver, ISO, and other styles
9

陳勇霖. "CAROL5:An Event-driven Semi-agent-oriented Programming Language-An Interpreter Using C++ Implementation." Thesis, 1996. http://ndltd.ncl.edu.tw/handle/14366583340634024230.

Full text
Abstract:
碩士
國立中央大學
資訊工程研究所
84
Most systems for developing educational software do not provide a good language or mechanism for establishing student model, designing teaching strategy and simulating learning companion in intelligent tutoriing systems (ITSs). It is very inconvenient and difficult for users while designing such a complex 　system. Agent-Oriented Programming (AOP) is a new programming paradigm that helps design large systems like ITSs, so we dsigned a programming language named CAROL5, and we combine event-driven, object-base and rule-base mechanisms to achieve the purpose of facilitating users to design AOP applications.　 　　In CAROL5, we preserve the rule-based programming style inherited from its pervious version, CAROL4, and delegation for resource sharing between objects, instead of inheritance.There is no difference between the state and behavior of an object, they are both variables of the object now. Event Sending & Handling Mechanism is a new feature added to the language. An agent can check his state continuously. When some condition is satisfied, the event will be triggered and broadcast to other agents. When other agents receive these events, they may respond, changing its state or other agents' states. This may, in tern, trigger other events and cause a chain reactions. The purpose is to allow agents act continuously.We hope we can transfer this system to network environment in the futuer, to achieve the goal of having the ability to write network agent applications. 　　In this thesis, we give a detail description of the method, syntax and semantics of CAROL5, and various examples are illustrated. The C++ implementation of the CAROL5 interpreter is also introduced. Combining the event-driven, object-base and rule-base programming style, CAROL5 is a flexible and powerful language that support the development of AOP applications.
APA, Harvard, Vancouver, ISO, and other styles
10

Matthews, Christopher. "SCOPE: Scalable Clustered Objects with Portable Events." Thesis, 2006. http://hdl.handle.net/1828/110.

Full text
Abstract:
Writing truly concurrent software is hard, scaling software to fully utilize hardware is one of the reasons why. One abstraction for increasing the scalability of systems software is clustered objects. Clustered objects is a proven method of increasing scalability. This thesis explores a user-level abstraction based on clustered objects which increases hardware utilization without requiring any customization of the underlying system. We detail the design, implementation and testing of Scalable Clustered Objects with Portable Events or (SCOPE), a user-level system inspired by an implementation of the clustered objects model from IBM Research’s K42 operating system. To aid in the portability of the new system, we introduce the idea of a clustered object event, which is responsible for maintaining the runtime environment of the clustered objects. We show that SCOPE can increase scalability on a simple micro benchmark, and provide most of the benefits that the kernel-level implementation provided.
APA, Harvard, Vancouver, ISO, and other styles

Books on the topic "Programming Languages, Event"

1

ACM, SIGPLAN Erlang Workshop (2nd 2002 Pittsburgh Pa ). ACM SIGPLAN Erlang Workshop '02: A satellite event of PLI 2002 : October 7, 2002, Pittsburgh, Pennsylvania, USA. New York: Association for Computing Machinery, 2002.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
2

A, Wall James, ed. Discrete event simulation: A practical approach. Boca Raton: CRC Press, 1993.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
3

Pooch, Udo W. Discrete event simulation: A practical approach. Boca Raton: CRC Press, 1993.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
4

Singh, Neeraj Kumar. Using Event-B for Critical Device Software Systems. London: Springer London, 2013.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
5

service), SpringerLink (Online, ed. Rewriting Logic and Its Applications: 9th International Workshop, WRLA 2012, Held as a Satellite Event of ETAPS, Tallinn, Estonia, March 24-25, 2012, Revised Selected Papers. Berlin, Heidelberg: Springer Berlin Heidelberg, 2012.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
6

Blanchette, Meghan, and Julie Steele, eds. Twisted Network Programming Essentials: Event-driven Network Programming with Python. 2nd ed. Beijing: O’Reilly Media, 2013.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
7

Dashorst, Martijn. Wicket in action. Greenwich, CT: Manning, 2009.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
8

Dashorst, Martijn. Wicket in action. Greenwich, CT: Manning, 2009.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
9

Practical UML statecharts in C/C++: Event-driven programming for embedded systems. 2nd ed. Amsterdam: Newnes/Elsevier, 2009.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
10

Object-oriented discrete-event simulation with Java: A practical introduction. New York: Kluwer Academic/Plenum Publishers, 2001.

Find full text
APA, Harvard, Vancouver, ISO, and other styles
More sources

Book chapters on the topic "Programming Languages, Event"

1

Palsberg, Jens. "Event Driven Software Quality." In Programming Languages and Systems, 165. Berlin, Heidelberg: Springer Berlin Heidelberg, 2006. http://dx.doi.org/10.1007/11924661_10.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Emmi, Michael, Pierre Ganty, Rupak Majumdar, and Fernando Rosa-Velardo. "Analysis of Asynchronous Programs with Event-Based Synchronization." In Programming Languages and Systems, 535–59. Berlin, Heidelberg: Springer Berlin Heidelberg, 2015. http://dx.doi.org/10.1007/978-3-662-46669-8_22.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Lodaya, K., and P. S. Thiagarajan. "A modal logic for a subclass of event structures." In Automata, Languages and Programming, 290–303. Berlin, Heidelberg: Springer Berlin Heidelberg, 1987. http://dx.doi.org/10.1007/3-540-18088-5_24.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Bouajjani, Ahmed, Michael Emmi, Constantin Enea, Burcu Kulahcioglu Ozkan, and Serdar Tasiran. "Verifying Robustness of Event-Driven Asynchronous Programs Against Concurrency." In Programming Languages and Systems, 170–200. Berlin, Heidelberg: Springer Berlin Heidelberg, 2017. http://dx.doi.org/10.1007/978-3-662-54434-1_7.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Busi, Nadia, and Gianluigi Zavattaro. "On the Expressiveness of Event Notification in Data-Driven Coordination Languages." In Programming Languages and Systems, 41–55. Berlin, Heidelberg: Springer Berlin Heidelberg, 2000. http://dx.doi.org/10.1007/3-540-46425-5_3.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Castellani, Ilaria, Mariangiola Dezani-Ciancaglini, and Paola Giannini. "Event Structure Semantics for Multiparty Sessions." In Models, Languages, and Tools for Concurrent and Distributed Programming, 340–63. Cham: Springer International Publishing, 2019. http://dx.doi.org/10.1007/978-3-030-21485-2_19.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Yuster, Raphael, and Uri Zwick. "Finding even cycles even faster." In Automata, Languages and Programming, 532–43. Berlin, Heidelberg: Springer Berlin Heidelberg, 1994. http://dx.doi.org/10.1007/3-540-58201-0_96.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Garrido, José M. "Relevant Aspects of the Java Programming Language." In Object-Oriented Discrete-Event Simulation with Java, 31–54. Boston, MA: Springer US, 2001. http://dx.doi.org/10.1007/978-1-4615-1319-3_3.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Alferes, J. J., F. Banti, and A. Brogi. "An Event-Condition-Action Logic Programming Language." In Logics in Artificial Intelligence, 29–42. Berlin, Heidelberg: Springer Berlin Heidelberg, 2006. http://dx.doi.org/10.1007/11853886_5.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Fonseca, Alcides, João Rafael, and Bruno Cabral. "Eve: A Parallel Event-Driven Programming Language." In Lecture Notes in Computer Science, 170–81. Cham: Springer International Publishing, 2014. http://dx.doi.org/10.1007/978-3-319-14313-2_15.

Full text
APA, Harvard, Vancouver, ISO, and other styles

Conference papers on the topic "Programming Languages, Event"

1

Nance, Richard E. "A history of discrete event simulation programming languages." In The second ACM SIGPLAN conference. New York, New York, USA: ACM Press, 1993. http://dx.doi.org/10.1145/154766.155368.

Full text
APA, Harvard, Vancouver, ISO, and other styles
2

Kiviat, Philip. "A brief introduction to discrete-event simulation programming languages." In The second ACM SIGPLAN conference. New York, New York, USA: ACM Press, 1993. http://dx.doi.org/10.1145/154766.155400.

Full text
APA, Harvard, Vancouver, ISO, and other styles
3

Ainsworth, Sam, and Timothy M. Jones. "An Event-Triggered Programmable Prefetcher for Irregular Workloads." In ASPLOS '18: Architectural Support for Programming Languages and Operating Systems. New York, NY, USA: ACM, 2018. http://dx.doi.org/10.1145/3173162.3173189.

Full text
APA, Harvard, Vancouver, ISO, and other styles
4

Erb, Benjamin, Gerhard Habiger, and Franz J. Hauck. "On the Potential of Event Sourcing for Retroactive Actor-based Programming." In PMLDC '16: Programming Models and Languages for Distributed Computing. New York, NY, USA: ACM, 2016. http://dx.doi.org/10.1145/2957319.2957378.

Full text
APA, Harvard, Vancouver, ISO, and other styles
5

Hu, Yongjian, and Iulian Neamtiu. "Static Detection of Event-based Races in Android Apps." In ASPLOS '18: Architectural Support for Programming Languages and Operating Systems. New York, NY, USA: ACM, 2018. http://dx.doi.org/10.1145/3173162.3173173.

Full text
APA, Harvard, Vancouver, ISO, and other styles
6

Prokopec, Aleksandar, and Martin Odersky. "Isolates, channels, and event streams for composable distributed programming." In SPLASH '15: Conference on Systems, Programming, Languages, and Applications: Software for Humanity. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2814228.2814245.

Full text
APA, Harvard, Vancouver, ISO, and other styles
7

Jensen, Casper S., Anders Møller, Veselin Raychev, Dimitar Dimitrov, and Martin Vechev. "Stateless model checking of event-driven applications." In SPLASH '15: Conference on Systems, Programming, Languages, and Applications: Software for Humanity. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2814270.2814282.

Full text
APA, Harvard, Vancouver, ISO, and other styles
8

Sadi, S., and P. Maes. "subTextile: Reduced event-oriented programming system for sensate actuated materials." In 2007 IEEE Symposium on Visual Languages and Human-Centric Computing. IEEE, 2007. http://dx.doi.org/10.1109/vlhcc.2007.37.

Full text
APA, Harvard, Vancouver, ISO, and other styles
9

Savrun-Yeniçeri, Gülfem, Michael L. Van de Vanter, Per Larsen, Stefan Brunthaler, and Michael Franz. "An Efficient and Generic Event-based Profiler Framework for Dynamic Languages." In PPPJ '15: Principles and Practices of Programming on the Java Platform. New York, NY, USA: ACM, 2015. http://dx.doi.org/10.1145/2807426.2807435.

Full text
APA, Harvard, Vancouver, ISO, and other styles
10

Torres Lopez, Carmen, Elisa Gonzalez Boix, Christophe Scholliers, Stefan Marr, and Hanspeter Mössenböck. "A principled approach towards debugging communicating event-loops." In SPLASH '17: Conference on Systems, Programming, Languages, and Applications: Software for Humanity. New York, NY, USA: ACM, 2017. http://dx.doi.org/10.1145/3141834.3141839.

Full text
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Programming Languages, Event' for particular source types:
Journal articles Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography