Dynamic Rebinding Research Articles

Molecularly imprinted polymers for selective extraction of rosmarinic acid from Rosmarinus officinalis L.

This study provides a robust and reproducible approach for selective extraction of rosmarinic acid (RA) using molecularly imprinted polymers (MIPs). Computational modeling and UV spectroscopic analysis were performed to optimize MIP synthesis. Consequently, six different bulk and surface imprinted polymers were generated using RA as the template. Binding performance of the imprinted polymers was evaluated using static equilibrium and complementary dynamic rebinding experiments. Despite the high selectivity of thus generated surface imprinted polymers, the corresponding bulk polymers exhibited better binding performance when serving as sorbents during solid phase extraction (SPE). An optimized molecularly imprinted solid phase extraction (MISPE) protocol was developed in respect to loaded amount of RA, composition of the loading solution, washing solvent, and elution volume. Thereby, a remarkably selective extraction of RA from real-world Rosmarinus officinalis L. extract with a recovery rate and purity of 81.96 ± 6.33% and 80.59 ± 0.30%, respectively, was achieved.

Strong Plasmon Enhancement of the Saturation Photon Count Rate of Single Molecules.

Plasmon resonances have appeared as a promising method to boost the fluorescence intensity of single emitters. However, because research has focused on the enhancement at low excitation intensity, little is known about plasmon–fluorophore coupling near the point where the dye saturates. Here we study plasmon-enhanced fluorescence at a broad range of excitation intensities up to saturation. We adopt a novel DNA-mediated approach wherein dynamic single-molecule binding provides a controlled particle–fluorophore spacing, and dynamic rebinding circumvents artifacts due to photobleaching. We find that near saturation the maximum photon count rate is enhanced by more than 2 orders of magnitude at the optimal particle–fluorophore spacing, even for a dye with a high intrinsic quantum yield. We compare our results to a numerical model taking into account dye saturation. These experiments provide design rules to maximize the photon output of single emitters, which will open the door to studying fast dynamics in real time using single-molecule fluorescence.

Dynamic Rebinding for Concurrent Object Groups: Theory and practice

In this paper we propose a new mechanism for Dynamic Rebinding, a particular kind of Dynamic Software Updating that focuses on modifying the workflow of a program. This mechanism is built upon the concurrency model of Concurrent Object Groups that is adopted in programming languages like Coboxes, Creol or ABS. Using this model, which extends and solves some of the limitations of Active Objects, it becomes possible for an update to wait for the program to reach a local quiescent state and then perform the update without creating any inconsistency in the program's state. We validate our mechanism by formally proving that i) no updates are performed when the program has not reached a local quiescent state, ii) an update is guaranteed to be applied if we first wait for the program to reach a local quiescent state, and iii) it is possible to perform different updates atomically. We also provide a type system that checks the good usage of the rebinding operator. We implemented a prototype supporting our mechanism in the toolchain of the ABS language, and we tested the implementation by supporting dynamic changes in the server policy of an industrial case study from the eCommerce Fredhopper platform, offered by SDL. Without our rebinding mechanism, supporting such dynamic changes in a provably correct manner would not have been so simple. Finally, we developed an implementation of type checking for the ABS language extended with our rebinding primitives, and successfully tested it for the case study discussed in the paper.

Type safe incremental rebinding

We extend the simply-typed lambda-calculus with a mechanism for dynamic and incremental rebinding of code. Fragments of open code which can be dynamically rebound are values. Differently from standard static binding, which is done on a positional basis, rebinding is done on a nominal basis, that is, free variables in open code are associated with names which do not obey α-equivalence. Moreover, rebinding is incremental, that is, just a subset of names can be rebound, making possible code specialization, and rebinding can even introduce new names. Finally, rebindings, which are associations between names and terms, are first-class values, and can be manipulated by operators such as overriding and renaming. We define a type system in which the type for a rebinding, in addition to specify an association between names and types (similarly to record types), is also annotated. The annotation says whether or not the domain of the rebinding having this type may contain more names than the ones that are specified in the type. We show soundness of the type system.

Synthesis of metronidazole-imprinted molecularly imprinted polymers by distillation precipitation polymerization and their use as a solid-phase adsorbent and chromatographic filler.

Metronidazole-imprinted polymers with superior recognition properties were prepared by a novel strategy called distillation-precipitation polymerization. The as-obtained polymers were characterized by Fourier-transform infrared spectroscopy, laser particle size determination and scanning electron microscopy, and their binding performances were evaluated in detail by static, kinetic and dynamic rebinding tests, and Scatchard analysis. The results showed that when the fraction of the monomers was 5 vol% in the whole reaction system, the prepared polymers afforded good morphology, monodispersity, and high adsorption capacity and excellent selectivity to the target molecule, metronidazole. The optimal binding performance is 12.41 mg/g for metronidazole just before leakage occurred and 38.51 mg/g at saturation in dynamic rebinding tests. Metronidazole-imprinted polymers were further applied as packing agents in solid-phase extraction and as chromatographic filler, both of which served for the detection of metronidazole in fish tissue. The results illustrated the recoveries of spiked samples ranged from 82.97 to 87.83% by using molecularly imprinted solid-phase extraction combined with a C18 commercial column and 93.7 to 101.2% by directly using the polymer-packed chromatographic column. The relative standard deviation of both methods was less than 6%.

Using OpenFlow to provide cut-through switching in MobilityFirst

Mobile devices are expected to become the Internet's predominant technology. Current protocols such as TCP/IP were not originally designed with mobility as a key consideration, and therefore underperform under challenging mobile and wireless conditions. MobilityFirst, a clean slate architecture proposal, embraces several key concepts centered around secure identifiers that inherently support mobility and trustworthiness as key requirements of the network architecture. This includes a hop-by-hop segmented data transport based on a globally unique identifier. This allows late and dynamic rebinding of end-point addresses to support mobility. While this provides critical gains in wireless segments, some overheads are incurred even in stable segments such as in the core. Bypassing routing-layer decisions in these cases, with lower layer cut-through forwarding, can improve said gains. In this work, we introduce a general bypass capability within the MobilityFirst architecture that provides better performance and enables both individual and aggregate flow-level traffic control. Furthermore, we present an OpenFlow-based proof-of-concept implementation of the bypass function using layer 2 VLAN tagging. We run experiments on the ORBIT and Global Environment for Network Innovations (GENI) testbeds to evaluate the performance and scalability of the solution. By implementing the bypass functionality, we are able to significantly reduce the number of messages processed by the controller as well as the number of flow rules that need to be pushed into the switches.

Dynamic rebinding for marshalling and update, via redex-time and destruct-time reduction

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example, when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically, it is provided only by ad hoc mechanisms that lack clean semantics. In this paper, we adopt a foundational approach, developing core dynamic rebinding mechanisms as extensions to the simply typed call-by-value λ calculus. To do so, we must first explore refinements of the call-by-value reduction strategy that delay instantiation, to ensure computations make use of the most recent versions of rebound definitions. We introduce redex-time and destruct-time strategies. The latter forms the basis for a λmarsh calculus that supports dynamic rebinding of marshalled values, while remaining as far as possible statically typed. We sketch an extension of λmarsh with concurrency and communication, giving examples showing how wrappers for encapsulating untrusted code can be expressed. Finally, we show that a high-level semantics for dynamic updating can also be based on the destruct-time strategy, defining a λupdate calculus with simple primitives to provide type-safe updating of running code. We show how the ideas of this simple calculus extend to more real-world, module-level dynamic updating in the style of Erlang. We thereby establish primitives and a common semantic foundation for a variety of real-world dynamic rebinding requirements.

Acute: High-level programming language design for distributed computation

AbstractExisting languages provide good support for typeful programming of stand-alone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper, we discuss programming-language support for such systems, focussing on their typing and naming issues. We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately built programs. The main features are (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type safety of associated values, for example, values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility. These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language run-time from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.

Towards a flexible global sensing infrastructure

Wireless sensor networks can potentially become larger, more prevalent, and interconnected via the Internet, forming a global sensing infrastructure that serves many users. In order to realize this and maximize its utility, it is necessary to develop a software architecture that enables new components to be integrated, multiple applications to share the same sensing substrate, and the integration of sensor and IP networks. We propose one such architecture that encodes applications as malleable, platform-independent, high-level mobile scripts. Multiple users are supported by allowing these scripts to execute concurrently, while flexibility is achieved by having them invoke platform-specific services. Services provide reusable functional capabilities that may vary across platforms and environmental conditions. They are platform-specific and may be discovered and redeployed on-demand at runtime. Service provision allows applications to exploit whatever computational capabilities are available, and new services to be added in response to changing application needs, resource availability, or environmental conditions. Our approach allows applications to function in diverse settings by employing dynamic rebinding of mobile scripts to different services as they execute over extended intervals across different types of networks.

Acute

Existing languages provide good support for typeful programming of standalone programs. In a distributed system, however, there may be interaction between multiple instances of many distinct programs, sharing some (but not necessarily all) of their module structure, and with some instances rebuilt with new versions of certain modules as time goes on. In this paper we discuss programminglanguage support for such systems, focussing on their typing and naming issues.We describe an experimental language, Acute, which extends an ML core to support distributed development, deployment, and execution, allowing type-safe interaction between separately-built programs. The main features are: (1) type-safe marshalling of arbitrary values; (2) type names that are generated (freshly and by hashing) to ensure that type equality tests suffice to protect the invariants of abstract types, across the entire distributed system; (3) expression-level names generated to ensure that name equality tests suffice for type-safety of associated values, e.g. values carried on named channels; (4) controlled dynamic rebinding of marshalled values to local resources; and (5) thunkification of threads and mutexes to support computation mobility.These features are a large part of what is needed for typeful distributed programming. They are a relatively lightweight extension of ML, should be efficiently implementable, and are expressive enough to enable a wide variety of distributed infrastructure layers to be written as simple library code above the byte-string network and persistent store APIs. This disentangles the language runtime from communication intricacies. This paper highlights the main design choices in Acute. It is supported by a full language definition (of typing, compilation, and operational semantics), by a prototype implementation, and by example distribution libraries.

Dynamic rebinding for marshalling and update, with destruct-time ?

Most programming languages adopt static binding, but for distributed programming an exclusive reliance on static binding is too restrictive: dynamic binding is required in various guises, for example when a marshalled value is received from the network, containing identifiers that must be rebound to local resources. Typically it is provided only by ad-hoc mechanisms that lack clean semantics.In this paper we adopt a foundational approach, developing core dynamic rebinding mechanisms as extensions to simply-typed call-by-value ? -calculus. To do so we must first explore refinements of the call-by-value reduction strategy that delay instantiation, to ensure computations make use of the most recent versions of rebound definitions. We introduce redex-time and destruct-time strategies. The latter forms the basis for a ? marsh calculus that supports dynamic rebinding of marshalled values, while remaining as far as possible statically-typed. We sketch an extension of ? marsh with concurrency and communication, giving examples showing how wrappers for encapsulating untrusted code can be expressed. Finally, we show that a high-level semantics for dynamic updating can also be based on the destruct-time strategy, defining a ? marsh calculus with simple primitives to provide type-safe updating of running code. We thereby establish primitives and a common semantic foundation for a variety of real-world dynamic rebinding requirements.