This research aims to study the Authority of act of Infallible Imam and its illustrations in Jurisprudence through a descriptive-analytic method. Tradition is the second source of legislation and includes the words, actions and writings infallible Imam. Its authority has been proved by the evidence of four including books, tradition, reason and consensus. One aspect of that tradition is the source of discrepancies between the three principal Shiite and Sunni, act of infallible Imam. For this purpose, it has been tried, first, through discussion to prove the infallibility of the Prophet and the Imams and the current tradition in terms of attribution to its owner. Also, we examined the expression of act and the innocent denote each independently. If the work is done from infallible Imam of his peculiarities, certainly will not be a place for spreading it to others verdict. He coordinates if it is not; it certainly is the verdict for all Muslims. As a result, his action is a proof to us.
This quarterly publication (July-September 1987) provides archival reports on developments in programs managed by JPL's Office of Telecommunications and Data Acquisition (TDA). In space communications, radio navigation, radio science, and ground-based radio astronomy, it reports on activities of the Deep Space Network (DSN) and its associated Ground Communications Facility (GCF) in planning, in supporting research and technology, in implementation, and in operations. This work is performed for NASA's Office of Space Tracking and Data Systems (OSTDS). In geodynamics, the publication reports on the application of radio interferometry at microwave frequencies for geodynamic measurements. In the Search for Extraterrestrial Intelligence (SETI), it reports on implementation and operations for searching the microwave spectrum. The latter two programs are performed for NASA's Office of Space Science and Applications (OSSA).
This study looks into the interplay between governments and transnational corporations (TNCs) regarding corporate social responsibility (CSR), and it investigates the potentials to link CSR to the international development agenda. The analysis focuses on Norwegian CSR, that illustrates a rare combination of strong state with significant ownership in national companies, a relatively small number of TNCs and a strong civil society. The results of the analysis indicate that the Norwegian government exercises a strong influence over corporate governance. However, despite an apparent alignment between the topics proposed by the State’s development cooperation agenda and those Norwegian companies are expected to report on, the analysis did not find proof of a transfer of agendas. Instead, businesses appear to use CSR as a communication tool, thus complying with the government’s desire to project a positive image of Norway internationally. Furthermore, the government appears to prioritize commercial goals and profitability.
Programmers use abstract data types to control the complexity of developing serial programs. Abstract data types promote modular programming by encapsulating state and operations on that state. In parallel environments abstract data types must also encapsulate the concurrency generation and synchronization code required for their correct use and present interfaces that require no information about the global concurrency pattern. An abstract data type is said to be implicitly synchronized if it meets these requirements. Implicitly synchronized abstract data types promote modular parallel software and help programmers manage the complexity of developing parallel programs. This paper defines the concept of implicitly synchronized abstract data types and shows how the implicitly parallel language Jade supports their development and use.
Orca is a simple, imperative parallel programming language, based on a form of distributed shared memory called shared data-objects. This paper discusses the suitability of Orca for parallel symbolic programming. Orca was not designed specifically for this application area, and it lacks several features supported in many languages for symbolic parallel computing, such as futures, automatic load balancing, and automatic garbage collection. On the other hand, Orca does give high-level support for sharing global state. Also, its implementation automatically distributes shared data (stored in shared objects). We first give a comparison between Orca and two other models: imperative message-passing systems and functional languages. We do so by looking at several key issues in parallel programming and by studying how each of the three paradigms deals with these issues. Next, we describe our experiences with writing parallel symbolic applications in Orca. This work indicates that Orca is quite suitable for such applications.
Research in compiler-compilers has contributed to making the implementation of domain-specific programming languages and syntax-based software design easier. We present a formalism for the description of formal translations which requires no more than common procedural programming skills and an understanding of the EBNF notation in order to use it effectively. The soundness and applicability of the ideas presented have been proved by implementing the Depot4 metasystem. Its metalanguage Ml4 extends EBNF in a symmetrical way, i.e. target descriptions utilize features already known from syntax definitions. The current implementation is by preprocessing into Oberon. Simplicity of use, flexibility and extendibility have been rated highly. The sample translation of a tiny Pascal subset into C demonstrates the power of the system. Additional potential areas of application are outlined and some advantages and disadvantages of the basic design decisions are discussed.
The conventional object-oriented paradigm provides client-server message passing as the primary means of interaction between objects. Although this is appropriate in situations where one objects requests a service from another object, there are other situations where one object, the observer, depends on state-changes or actions occurring at another object, the target. In those situations, the object-oriented paradigm requires the target object to notify the observer objects, despite the fact that the target object does not benefit from the interaction. This inverted interaction scheme leads to problems such as increased coupling and decreased understandability, maintainability and reusability of the resulting classes. In the analysis of object interactions one can identify four roles: the benefitor, the establisher, the sender and the receiver. The aforementioned problems result from the fact that in client-server interaction, the benefitor and the sender are not always the same object. To address this, we propose the notion of causal connections, an alternative interaction mechanism complementing the traditional client-server interaction. Two implementations of causal connections are described; one in the context of C++ and another using the layered object model. It is shown that causal connections solve the problems mentioned above.
One unique feature of logic languages is their ability to succinctly and declaratively express non-determinacy and hence search. Improving search efficiency is one of the main goals of AI and, by studying how redundant search may be factored out, this paper contributes to this goal. In logic programming, alternatives can be specified by a set of sentences defining the same predicate. By backtracking, considering in turn each of these sentences, these alternatives can be explored until a solution (if one exists) is found. However, though backtracking is essential for certain parts of a program, typically many predicates are deterministic, and most queries to a program have no more than one solution. Providing for non-determinacy can slow down the execution of a program on a uniprocessor and limit the scope for parallel execution on a multiprocessor. As a consequence, programmers are often forced to resort to the non-logical features of the language to ensure any determinacy is fully exploited. A number of papers on determinacy and its detection have been published. However, because of the diversity of applications for determinacy analysis, there has been a similar diversity of definitions of determinacy and its related concepts. This paper reformulates the determinacy definitions in a uniform way, identifying and contrasting the different approaches. Techniques for detecting and exploiting determinacy are also reviewed together with some directions for future research.
Set-based languages have emerged as a powerful means for expressing not only programs but also requirements, test cases and so on. However, a uniform compilation schema for sets has not yet been completely developed. The present paper tries to overcome this lack using a set-based logic language, SL( set language), as target.The approach is based on an imperative abstract machine, the SAM( set abstract machine). The translation from SL to SAL (SAM assembly language) is described and all the possible optimizations, both at source code level and at assembly code level, are detailed. The potentials for identifying parallel flows of computations are analysed. Several examples of compilations are presented and discussed.
There are many general purpose applications that could benefit from the modest use of parallelism. These include such basic tools as spreadsheets, databases, word processors and compilers. Due to the lack of good programming support tools, general purpose applications are unable to make effective use of parallel computation available on workstation networks. We propose a new model of parallel programming for general purpose applications, called composite tree parallelism, which has been developed by making a small number of simple alterations to the basic data parallel programming model. Composite nee parallelism allows programmers to write coarse grained tree-based parallel data structures, in a form that retains the power and simplicity of data parallelism. In this paper, we present the composite tree parallel model, and its implementation as an extension to an object oriented Scheme and the Java programming language and our initial experiences with developing and running composite parallel programs on a workstation cluster.
Dactl is an experimental language programming language based on fine grain graph transformations. It was developed in the context of a large parallel reduction machine project. The design of the language is outlined, and examples given of its use both as a compiler target language and as a programming language. Dactl has a formal semantics and stable implementations on a number of platforms.
Two superficially similar graph rewriting formalisms, Interaction Nets and MONSTR, are studied. Interaction Nets come from multiplicative Linear Logic and feature undirected graph edges, while MONSTR arose from the desire to implement generalized term graph rewriting efficiently on a distributed architecture and utilizes directed graph arcs. Both formalisms feature rules with small left-hand sides consisting of two main graph nodes. A translation of Interaction Nets into MONSTR is described for both typed and untyped nets, while the impossibility of the opposite translation rests on the fact that net rewriting is always Church–Rosser while MONSTR rewriting is not. Some extensions to the net formalism suggested by the relationship with MONSTR are discussed, as well as some related implementation issues.
We propose an efficient scheme of constructing states in bottom-up tree pattern matching with dynamic programming technique for code generation. The proposed scheme, which is derived from relations on tree patterns, is efficient because its smaller size makes it possible to avoid unfruitful tests. Furthermore, the relevant analyses are largely achieved at compile-compile time, which secures actual efficiency of code generator at compilation time.
A methodology is developed for mapping a wide class of concurrent logic languages( CLLs) onto Dactl, a compiler target language based on generalized graph rewriting. We show how features particular to the generalized graph rewriting model (such as non-root overwrites and sharing) can be used to implement CLLs. We identify problems in the mapping of a concurrent logic program to an equivalent set of rewrite rules and provide solutions. We also show some important optimizations and compilation techniques that can be adopted in the process. Finally, we take advantage of the underlying graph reduction model to enhance a concurrent logic program with some capabilities found usually only in functional languages such as lazy evaluation, sharing of computation and higher order programming.
An incremental parser deals with the reparsing process when modifications have been made to a program. It can be widely used in language-based editors or incremental compiling and interpreting environments. In this paper, we present a new approach to this problem: parsing non-terminals directly in incremental parsers. The advantages of this approach are that the incremental parsers are more efficient because subtrees are directly considered for reuse; multiple modifications are more easily and more efficiently handled; and the incremental parsers are much simpler.
Programmers spend much of their time analysing and manipulating the source code of programs. Thus, one way to make programming easier would be to make it easier to write metaprograms, that is, programs that manipulate other programs. Unfortunately, building a metaprogramming environment (MPE) for C++ is probably impossible because of the language's text-based preprocessing constructs. In this paper, we discuss how to build an MPE for a well-behaved subset of C++ in which certain uses of the preprocessor are banned. Given a choice between being able to use all C++ and being able to program in an MPE, many C++ programmers would prefer the latter.
Frameworks for interprocedural data ow analysis (DFA) often have a foundational character: designing concrete applications requires usually a deep understanding of the framework. Here, we reconsider interprocedural DFA from an application-oriented point of view, where all details irrelevant for application are hidden. In this view the underlying framework, which captures programs with mutually recursive procedures, global and local variables, formal value and reference parameters, reduces to a cook book of (1) how to specify interprocedural DFAs and (2) how to prove them precise with respect to a program property of interest. Thus only knowledge about the speciication level is required. Moreover, this presentation also yields the basis for a tool kit implementation: speciication parameters and generic algorithms of the framework become speciication tools allowing concise speciications and computation tools processing them. A tool kit prototype has been implemented within MetaFrame, a programming environment for the construction and veriication of complex software systems. The beneets of the approach are demonstrated by a collection of practically relevant precise interprocedural DFAs ranging from classical bit-vector problems like available expressions and live variables to sophisticated and powerful optimizations like the optimal elimination of interprocedural partial redundancies. 1. Motivation Data ow analysis (DFA) is concerned with the static analysis of objects like programs, systems, or programming environments in order to support applications like system reengi-neering, program validation or the construction of optimizing compilers. We focus on the generation of eecient code by optimizing compilers in this article, the classical application of DFA. In this context, designers of a DFA are typically faced with the problem of how to construct an algorithm that determines the set of program points of an argument program which satisfy a certain property of interest. Though this problem has been studied in detail for the intraprocedural case, the construction of interprocedural analyses is still 2 Part of the work was done while the author was supported by the Deutsche Forschungsgemeinschaft grant La 426/11-1. 2 Jens Knoop et al. characterized by heuristics and ad-hoc techniques. Moreover, frameworks for interproce-dural DFA often have a foundational character: designing concrete applications requires usually a deep understanding of the framework. The point of this paper is to reconsider interprocedural DFA in a cook book view, where all details irrelevant for application are hidden in order to support the designer of a DFA by structuring and simplifying the construction of provably correct and precise interprocedu-ral DFA-algorithms. The …
New, simple conditions are provided which allow the conclusion that in the case of several well-known Prolog programs the uni®cation algorithm can be replaced by iterated matching. As already noticed by other researchers, such a replacement oers the possibility of improving the eciency of a program execution. These results improve on earlier results because (in most cases) they allow proof of uni®cation-freeness for a larger class of programs and queries and because they require far less machinery. In particular, the conditions provided are always checkable in an automatic way.
Arbitral justice becomes a universal phenomenon requiring the involvement of all economic and legal players in developed and developing countries.OHADA is a common law that aims to secure legal security for regional and foreign economic agents by offering a vast economic space. The People's Republic of China (PRC) is an emerging country seeking to increase its economic participation in the global context. As economic interdependence increases, business disputes are more likely.This article compares two legal systems in the international commercial arbitration field: the legal system of OHADA and the PRC's legal system; especially in the effectiveness and the remedies of the arbitrators' decisions.
