Abstract: JavaScript frameworks, such as jQuery, are widely used for developing web applications. To facilitate using these JavaScript frameworks to implement a feature (e.g., functionality), a large number of programmers often search for code snippets that implement the same or similar feature. However, existing code search approaches tend to be ineffective, without taking into account the fact that JavaScript code snippets often implement a feature based on various relationships (e.g., sequencing, condition, and callback relationships) among the invoked framework API methods. To address this issue, we present a novel Relationship-Aware Code Search (RACS) approach for finding code snippets that use JavaScript frameworks to implement a specific feature. In advance, RACS collects a large number of code snippets that use some JavaScript frameworks, mines API usage patterns from the collected code snippets, and represents the mined patterns with method call relationship (MCR) graphs, which capture framework API methods’ signatures and their relationships. Given a natural language (NL) search query issued by a programmer, RACS conducts NL processing to automatically extract an action relationship (AR) graph, which consists of actions and their relationships inferred from the query. In this way, RACS reduces code search to the problem of graph search: finding similar MCR graphs for a given AR graph. We conduct evaluations against representative real-world jQuery questions posted on Stack Overflow, based on 308,294 code snippets collected from over 81,540 files on the Internet. The evaluation results show the effectiveness of RACS: the top 1 snippet produced by RACS matches the target code snippet for 46% questions, compared to only 4% achieved by a relationship-oblivious approach.

Abstract: For static analysis researchers, Android software presents a wide variety of interesting challenges. The target of our work is static detection of energy-drain defects in Android applications. The management of energy-intensive resources (e.g., GPS) creates various opportunities for software defects. Our goal is to detect statically “missing deactivation” energy-drain defects in the user interface of the application. First, we define precisely two patterns of run-time energy-drain behaviors, based on modeling of Android GUI control-flow paths and energy-related listener leaks along such paths. Next, we define a static detection algorithm targeting these patterns. The analysis considers valid interprocedural control-flow paths in a callback method and its transitive callees, in order to detect operations that add or remove listeners. Sequences of callbacks are then analyzed for possible listener leaks. Our evaluation considers the detection of GUI-related energy-drain defects reported in prior work, as well as new defects not discovered by prior approaches. In summary, the detection is very effective and precise, suggesting that the proposed analysis is suitable for practical use in static checking tools for Android.

Abstract: JavaScript has become one of the most popular languages in practice Developers now use JavaScript not only for the client-side but also for server-side programming, leading to "full-stack" applications written entirely in JavaScript Understanding such applications is challenging for developers, due to the temporal and implicit relations of asynchronous and event-driven entities spread over the client and server side We propose a technique for capturing a behavioural model of full-stack JavaScript applications' execution The model is temporal and context-sensitive to accommodate asynchronous events, as well as the scheduling and execution of lifelines of callbacks We present a visualization of the model to facilitate program understanding for developers We implement our approach in a tool, called Sahand, and evaluate it through a controlled experiment The results show that Sahand improves developers' performance in completing program comprehension tasks by increasing their accuracy by a factor of three

Abstract: . CellLab-CTS 2015 is a Python-language software library for creating two-dimensional, continuous-time stochastic (CTS) cellular automaton models. The model domain consists of a set of grid nodes, with each node assigned an integer state code that represents its condition or composition. Adjacent pairs of nodes may undergo transitions to different states, according to a user-defined average transition rate. A model is created by writing a Python code that defines the possible states, the transitions, and the rates of those transitions. The code instantiates, initializes, and runs one of four object classes that represent different types of CTS models. CellLab-CTS provides the option of using either square or hexagonal grid cells. The software provides the ability to treat particular grid-node states as moving particles, and to track their position over time. Grid nodes may also be assigned user-defined properties, which the user can update after each transition through the use of a callback function. As a component of the Landlab modeling framework, CellLab-CTS models take advantage of a suite of Landlab's tools and capabilities, such as support for standardized input and output.

Abstract: The responsiveness of the GUI in an Android application is an important component of the user experience. Android guidelines recommend that potentially-expensive operations should not be performed in the GUI thread, but rather in separate threads. The responsiveness of existing code can be improved by introducing such asynchronous processing, either manually or automatically. One simple view is that all potentially-expensive operations should be removed from the GUI thread. We demonstrate that this view is too simplistic, because run-time cost under reasonable conditions may often be below the threshold for poor responsiveness. We propose a profiling approach to characterize response times as a function of the size of a potentially-expensive resource (e.g., shared preferences store, bitmap, or Silt database). By manipulating and "amplifying" such resources automatically, we can obtain a responsiveness profile for each GUI-related callback. The profiling is based on a static analysis to generate tests that trigger expensive operations, followed by a dynamic analysis of amplified test execution. Based on our evaluation, we conclude that many operations can be safely left in the GUI thread. These results highlight the importance of choosing carefully - based on profiling information - the operations that should be removed from the GUI thread, in order to avoid unnecessary code complexity.

Abstract: Android is the most commonly used mobile device operation system. The core of Android, the System Server (SS), is a multi-threaded process that provides most of the system services. Based on a new understanding of the security risks introduced by the callback mechanism in system services, we have discovered a general type of design flaw. A vulnerability detection tool has been designed and implemented based on static taint analysis. We applied the tool on all the 80 system services in the SS of Android 5.1.0. With its help, we have discovered six previously unknown vulnerabilities, which are further confirmed on Android 2.3.7-6.0.1. According to our analysis, about 97.3% of the entire 1.4 billion real-world Android devices are vulnerable. Our proof-of-concept attack proves that the vulnerabilities can enable a malicious app to freeze critical system functionalities or soft-reboot the system immediately. It is a neat type of denial-of-service at-tack. We also proved that the attacks can be conducted at mission critical moments to achieve meaningful goals, such as anti anti-virus, anti process-killer, hindering app updates or system patching. After being informed, Google confirmed our findings promptly. Several suggestions on how to use callbacks safely are also proposed to Google.

Abstract: The labelling of sensor data with information about the real world, e. g. the activity a human performs, is called annotation. In this paper we perform an analysis of existing live annotation systems and derive the requirements for a general annotation approach. Based on the requirements, we propose a tool support that uses a database schema for the labelling of sensor data. Instead of video logs that are commonly used to add this information after recording, our approach aims at online annotation of the sensor data, i. e. at the moment the observation is made in the real world. Our database schema enables the automatic generation of a user interface that can be used from (human) observers. In difference to many existing annotation tools, our schema includes a possibility to define callback functions that may be used to check the semantic correctness of the annotation. We show that our approach is working with a generated online annotation system in a home environment.

Abstract: A system is disclosed that assists contact center agents with servicing customer enquiries. A wireless caller with an enquiry calls a contact center and is prompted to leave a voice message and accept a text callback as a response. The voice message is processed by a speech analytics system that extracts certain keywords in the voice message and develops a transcript as well. Upon selecting an available agent to provide the response, the keywords and transcript are presented to the agent along with a draft text response, formulated by the system using the identified keywords. Additional resources may be provided as necessary to the agent, who can also review the original audio recording. Upon reviewing and potentially editing the text response, the agent causes the text to be sent to the wireless caller, which may be sent as an SMS text, or in some other form.

Abstract: In the software and system modeling community, research on domain-specific modeling languages (DSMLs) is focused on providing technologies for developing languages and tools that allow domain experts to develop system solutions efficiently.Unfortunately, the current lack of support for explicitly relating concepts expressed in different DSMLs makes it very difficult for software and system engineers to reason about information spread across models describing different system aspects.As a particular challenge, we present in this paper how we dealt with relationships between heterogeneous behavioral models to support their concurrent and coordinated execution. This was achieved by providing dedicated meta-language to define the behavioral semantics of DSMLs and their coordination. The approach made explicit a formal model of the control flow (MoCC); domain-specific actions (DSA) and a well-defined protocol between them (incl., mapping, feedback and callback) reified through explicit domain-specific events (DSE). The protocol is then used to infer a relevant behavioral language interface for specifying coordination patterns to be applied on conforming executable models.As a result, heterogeneous languages and their relationships can be developed in the GEMOC studio, which provides extensive support to run and debug heterogeneous models. This is outlined in the paper on the definition of the Marked Graph language and its coordination with a scenario language.

Abstract: In the previous chapters I’ve tried to keep the code examples as independent of everything else as possible (especially the reactive code examples), which is why I haven’t mentioned any particular library just yet, and that is why you can’t just copy and paste some of it and just run it.

Abstract: Webcharts is a JavaScript library built on top of D3.js that creates reusable, flexible, interactive charts that are highly customizable. Webcharts provides a method for creating commonly-used charts, including bar charts, scatterplots, and timelines, through a simple configuration scheme. Charts created with Webcharts allow users to dynamically manipulate chart data, appearance, and behavior both through callback functions and input elements that are tied to chart objects. This approach allows users to create reusable charts that range from simple static graphics to complex interactive data exploration tools with custom user interfaces, all using the same library.

Abstract: The invention relates to the mobile application development. The invention provides a method of asynchronously calling a native by a js in a mobile application. The method is used for solving the problem in the prior art that in the process of the method of asynchronously calling the native by the js, when a native end calls back the return result of callback functions of the js, if a js end transmits the callback function code to the native, and lets the webview execute, the code on the native end is complex and is hard to reuse; if the js end does not transmit the js callback function code to the native end, the native cannot call the anonymous callback functions of the js. The method comprises that the js end caches the callback functions and builds a public callback function, wherein the public callback function comprises mapping relationships between the cached callback functions and the corresponding identifiers of the cached callback functions; then the js end transmits the identifiers to the native end; and then the native end receives the transmitted identifiers; the public callback function is called back after service logic is executed; finally, the public callback function obtains the corresponding cached callback functions according to the transmitted identifiers and mapping relationships; and the native end calls the corresponding cached callback functions and finishes callback. The method is applicable to the hybrid development mode.

Abstract: In the software and systems modeling community, research on domain-specific modeling languages (DSMLs) is focused on providing technologies for developing languages and tools that allow domain experts to develop system solutions efficiently. Unfortunately, the current lack of support for explicitly relating concepts expressed in different DSMLs makes it very difficult for software and system engineers to reason about information spread across models describing different system aspects [4]. As a particular challenge, we investigate in this paper relationships between, possibly heterogeneous, behavioral models to support their concurrent execution. This is achieved by following a modular executable metamodeling approach for behavioral semantics understanding, reuse, variability and composability [5]. This approach supports an explicit model of concurrency (MoCC) [6] and domain-specific actions (DSA) [10] with a well-defined protocol between them (incl., mapping, feedback and callback) reified through explicit domain-specific events (DSE) [12]. The protocol is then used to infer a relevant behavioral language interface for specifying coordination patterns to be applied on conforming executable models [17]. All the tooling of the approach is gathered in the GEMOC studio, and outlined in the next section. Currently, the approach is experienced on a systems engineering language provided by Thales, named Capella 7. The goal and current state of the case study are exposed in this paper. 7 Cf. https://www.polarsys.org/capella/

Abstract: The invention discloses a data interaction method The method includes: detecting a data processing request; according to the data processing request, obtaining a preset data callback interface of a third party application server corresponding to a task identification accessed by a platform server; according to the data callback interface and the data processing request, generating an interface calling request corresponding to the data processing request according to a preset generation rule; according to an equipment identification code of a mobile terminal and a preset ciphertext string corresponding to the task identification, signing for the interface calling request; and sending the interface calling request after signing to the third party application server The invention also discloses a data interaction apparatus and a system According to the method, the apparatus, and the system, the technical problem of interaction limitation of the mobile terminal between the platform server and the third party application server is solved, and the security of interaction data among the mobile terminal, the platform server, and the third party application server is also improved

Abstract: In today’s web applications asynchronous requests to remote services using callbacks or futures are omnipresent. The continuation of such a non-blocking task is represented as a callback function that will later be called with the result of the request. This style of programming where the remainder of a computation is captured in a continuation function is called continuation-passing style (CPS). This style of programming can quickly lead to a phenomenon called “call- back hell”, which has a negative impact on the maintain- ability of applications that employ this style. Several alter- natives to callbacks are therefore gaining traction within the web domain. For example, there are a number of frameworks that rely on automatically transforming sequential style code into the continuation-passing style. However, these frame- works often employ a conservative approach in which each function call is transformed into CPS. This conservative approach can sequentialise requests that could otherwise be run in parallel. So-called delimited continuations can remedy, but require special marks that have to be manually inserted in the code for marking the beginning and end of the continuation. In this paper we propose an alternative strategy in which we apply a delimited CPS transformation that operates on a Program Dependence Graph instead to find the limits of each continuation.We implement this strategy in JavaScript and demonstrate its applicability to various web programming scenarios.

Abstract: Examples of the present disclosure describe systems and methods of data ingress and egress using callback notifications. In an example, a callback notification may be received. The notification may comprise one or more resources, which may be extracted. The extracted resources may be associated with resource identifiers. One or more inference rules from an inference ruleset may be applied to the extracted resources to generate any related inferred relationships. The resource identifiers and inferred relationships may be stored in an isolated collection. The content or structure of the isolated collection may satisfy a notification rule within a notification ruleset. The notification rule may be associated with a recipient. As a result of the determination, the recipient may receive a callback notification. In some examples, the callback notification may comprise a change notification or one or more resource identifiers, associated resources, or relationships from the isolated collection.

Abstract: The invention discloses a data interaction method applied to a platform server The platform server offers an interactive platform in order to display a task of a third-party application The data interaction method comprises steps of detecting a data processing request including a user identifier and a task identifier; according to the data processing request, acquiring a data callback interface of a third-party application server corresponding to the task identifier set in advance and accessed by the platform server; and generating an interface call request corresponding to the data processing request according to a preset generation rule, the data callback interface, and the data processing request, and sending the interface call request to the third-party application server The invention also discloses a data interaction device and system The data interaction method, device and system solve a technical problem of interactive restriction between a PC terminal and the third-party application server via the platform server, and enhance the security of interactive data among the PC terminal, the platform server, and the third-party application server

Abstract: The invention discloses a monitoring method and a system for positioning illegal callback service. The method comprises steps: signaling in the case of adopting various protocols for communication when callback service is initiated based on a communication network is monitored, and a monitored result is obtained; the monitored result is analyzed, a first number included in message signaling for a specific protocol is obtained, a first time stamp is marked, and the first number is a real number; a pre-configured recognition rule is extracted, a number and time matching mode is obtained, the first number and the first time stamp are matched according to the number and time matching mode, a matched result is obtained, when the matched result is detected to be stored in a preset record, the callback service is determined to be suspected as illegal callback service, first processing is carried out; and a response is given to the first processing, the callback service is determined to be the illegal callback service, and the illegal callback service is intercepted.

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.

Abstract: The embodiment of the invention discloses a method, device and electronic equipment for inputting dynamic link library documents and relates to a document input technology. The method, the device and the electronic equipment can increase a success rate for inputting the dynamic link library documents. The method comprises the steps that processes are distributed according to a received loading request for the dynamic link library documents, and a loading module callback function is called; the loading module callback function is analyzed, and a universal leading-in list address is acquired according to parameters of the loading module callback function; a universal leading-in list corresponding to the universal leading-in list address is read, and the dynamic link library documents which are not stored in the universal leading-in list are extracted from the dynamic link library documents contained in the loading request for the dynamic link library documents; the extracted dynamic link library documents are written into the universal leading-in list, and an updated universal list is generated and then written into internal memory space of the processes; and the dynamic link library documents in the updated universal list are loaded in the internal memory space. The method, the device and the electronic equipment disclosed by the invention are applicable to inputting of safety-type dynamic link library documents which can be intercepted easily.

Abstract: The invention discloses a data interaction method comprising the following steps that a platform server detects a data processing request including a user identifier and a task identifier; the platform server, according to the data processing request, acquires a data callback interface of a third-party application server corresponding to the task identifier set in advance and accessed by the platform server; the platform server generates an interface call request of the data processing request according to a protocol rule corresponding to the data callback interface, and sends the interface call request to the third-party application server; the third-party application server, according to the interface call request, queries whether a target account corresponding to the user identifier satisfies a task condition corresponding to the task identifier; if yes, the third-party application server sends a data packet corresponding to the task identifier to the target account. The invention also discloses a data interaction system. The data interaction method and system reduce operation difficulty in task data packet acquisition.

Abstract: The embodiment of the application discloses a client application partial updating method and apparatus. Characteristics and a JNI (Java Native Interface) mechanism of an Android system framework are utilized; after acquiring a Java target method from an update pack, a client application transmits the Java target method to a local layer, stores the Java target method and associates the Java target method with a JNI local callback method; when the client application operates on a Dalvik virtual machine and needs to call a Java method to be replaced, the JNI local callback method, instead of an original Java method to be replaced, is called; and the JNI local callback method calls the Java target method according to parameters transmitted by the client application so as to complete partial updating on a code of the client application. The client application partial updating method disclosed by the application can be accurate to a Method level of a Java class.

Abstract: The invention discloses a data connection establishing method and device and belongs to the network technical field. The method comprises the following steps: receiving a data packet sent by a terminal, wherein the data packet carries target application identification and transmission data; extracting the target application identification; determining a target callback function corresponding to a target application according to the target application identification and a preset callback function correspondence table; and operating the target callback function, and sending the transmission data to the target application. The method is characterized by extracting the target application identification carried in the data packet sent by the terminal, determining the target callback function according to the target application identification and the preset callback function correspondence table, and operating the target callback function to enable the transmission data to be sent to the target application, such that the received data packets can be subjected to unified management and sending, and the terminal does not need to establish connection with too many ports, and port resources can be saved.

Abstract: The invention provides a permission management method and a permission management system, applied in an Android system. The permission management method comprises the following steps that: a callback function is registered in an permission management service; the callback function is defined in a callback interface; when an APP application is received by the permission management service, the permission management service calls the callback function to display permission related information of the APP application for a user to check permission; and after checking permission, the user transmits the permission checking result to the permission management service as a system notice. The callback function comprises a user-defined permission checking panel object of a Check Permission View Pane class, and the permission checking panel object displays the permission related information of the APP application. According to the method and the system provided by the invention, a permission management flow is realized through a callback mechanism, abnormity that application programs have no response when the system checks permission is avoided radically; and meanwhile, through the customized personalized permission checking panel, the permission checking view can be friendly more.

Abstract: The invention discloses a callback message processing method and a queue management system. The method and the system are used for ensuring reliability of a callback function and improving a callback success rate. The method provided by the invention comprises the steps that the queue management system reads a first callback message from a distributed message queue and reserves the first callback message in the distributed message queue, wherein the distributed message queue comprises at least one callback message obtained from a provider background server; the queue management system sends a callback request to a user background server, wherein the callback request comprises a first callback message and a first message identifier; the queue management system judges whether callback response sent by the user background server is received in a preset time period or not; when the queue management system receives the callback response in the time period, the queue management system obtains a message identifier carried in the callback response; and if the message identifier carried in the callback response is the first message identifier, the queue management system deletes the first callback message corresponding to the first message identifier from the distributed message queue.

Abstract: A device may receive, by a kernel of the device and from a loadable kernel module of the device, information that instructs the kernel to invoke a callback function associated with the loadable kernel module based on an execution of a hook of the kernel. The device may receive, by the kernel of the device and from an application of the device, a socket application programming interface (API) call. The socket API call may include control information. The device may execute, by the kernel of the device, the hook based on receiving the socket API call. The device may invoke, by the kernel of the device, the callback function associated with the loadable kernel module based on executing the hook to permit a functionality associated with the callback function to be provided. The kernel may provide the control information, associated with the socket API call, to the callback function as an argument.

Abstract: The invention discloses a graphic interface operating system and an implementation method thereof. The implementation method comprises the steps that an interface element table of an MCU memory is filled with the attribute values of texts, icons, touch control and layout of each interface and a callback function of a configuration event in advance; the attribute values of the texts, icons, touch control and layout of each interface and the callback function of the event in the interface element table are read; a first interface is called, the attribute values of the texts, icons, touch control and layout of the specific interface are loaded to generate the specific interface, and the interface generated on display equipment is displayed by calling a second interface; a third interface is called to read input information from input equipment in real time, and when the event is triggered, the callback function of the event is called to refresh the interface. According to the technical scheme, cost is reduced, and high portability, maintainability and extendibility are achieved.

Abstract: The heavy use of event-callback mechanism in frameworks like Android causes challenges for static analysis. Modelling of callback mechanisms for Android applications (app for short) is becoming a major method to address such challenges. In this work, we aim to construct a generic callback-related model that supports path-sensitive analysis. We consider three unresolved challenges in the existing modelling approaches: 1) building connections between different components; 2) identifying path-sensitive conditions; 3) handling the system-driven callbacks and fine-grained lifecycle callbacks. We propose algorithms for constructing a generic path-sensitive callback model and present a prototype model constructor, Andro Checker, to validate our approach. We evaluate 20 real-world apps using Andro Checker. The evaluation result shows that our method and tool have a strong capability in modelling path conditions and inter-component invocations.