Segui questo link per vedere altri tipi di pubblicazioni sul tema: Computer programs.
Tesi sul tema "Computer programs"
Cita una fonte nei formati APA, MLA, Chicago, Harvard e in molti altri stili
Vedi i top-50 saggi (tesi di laurea o di dottorato) per l'attività di ricerca sul tema "Computer programs".
Accanto a ogni fonte nell'elenco di riferimenti c'è un pulsante "Aggiungi alla bibliografia". Premilo e genereremo automaticamente la citazione bibliografica dell'opera scelta nello stile citazionale di cui hai bisogno: APA, MLA, Harvard, Chicago, Vancouver ecc.
Puoi anche scaricare il testo completo della pubblicazione scientifica nel formato .pdf e leggere online l'abstract (il sommario) dell'opera se è presente nei metadati.
Vedi le tesi di molte aree scientifiche e compila una bibliografia corretta.
1
Liang, Donglin. "Developing practical program analyses for programs with pointers". Diss., Georgia Institute of Technology, 2002. http://hdl.handle.net/1853/8203.
Testo completo
2
Bhullar, Amarjit Singh. "Program understanding tool for MODSIM programs (PUMP)". Thesis, University of Ottawa (Canada), 2001. http://hdl.handle.net/10393/9332.
Testo completoAbstract (sommario):
The focus of software engineering has traditionally been oriented toward new software construction inspite of the fact that very substantial costs arise in the maintenance phase of the software lifecycle. A key element in the maintenance phase is "program understanding" because the individuals assigned this task are typically distinct from those on the development team. Tools to assist with program understanding have, nevertheless, received only modest attention in recent years. In this thesis the topic is explored within the context of the development of a particular program understanding tool called PUMP. PUMP (Program Understanding Tool for MODSIM Programs) is a tool developed to help understand simulation models written in the object-oriented simulation language called MODSIM programs. It has a simple graphical user interface (GUI) and may be used for both system exploration and for browsing purposes as part of a professional software development tool. It quickly displays and provides views of complex inheritance trees, making it an important tool for understanding object-oriented systems.
3
Nagulakonda, Vikram. "Assertion seeding development of program instrumentation through iterative formal analysis /". Morgantown, W. Va. : [West Virginia University Libraries], 1999. http://etd.wvu.edu/templates/showETD.cfm?recnum=1080.
Testo completoAbstract (sommario):
Thesis (M.S.)--West Virginia University, 1999.Title from document title page. Document formatted into pages; contains v, 80 p. : ill. Includes abstract. Includes bibliographical references (p. 33-35).
4
Murrill, Branson Wayne. "Error flow in computer programs". W&M ScholarWorks, 1991. https://scholarworks.wm.edu/etd/1539623805.
Testo completoAbstract (sommario):
White box program analysis has been applied to program testing for some time, but this analysis is primarily grounded in program syntax, while errors arise from incorrect program semantics. We introduce a semantically-based technique called error flow analysis, which is used to investigate the behavior of a program at the level of data state transitions. Error flow analysis is based on a model of program execution as a composition of functions that each map a prior data state into a subsequent data state. According to the fault/failure model, failure occurs when a fault causes an infection in the data state which then propagates to output. A faulty program may also produce coincidentally correct output for a given input if the fault resists infection, or an infection is cancelled by subsequent computation. We investigate this phenomenon using dynamic error flow analysis to track the infection and propagation of errors in the data states of programs with seeded faults. This information is gathered for a particular fault over many inputs on a path-by-path basis to estimate execution, infection, and failure rates as well as characteristics of error flow behavior for the fault. Those paths that exhibit high failure rates would be more desirable to test for this fault than those with lower failure rates, and we look for error flow characteristics that correlate with high failure rate. We present the results of dynamic error flow experiments on several programs, and suggest ways in which error flow information can be used in program analysis and testing.
5
Green, Thomas Alan. "Computer programs supporting instruction in acoustics". Thesis, Monterey, Calif. : Springfield, Va. : Naval Postgraduate School ; Available from National Technical Information Service, 1996. http://handle.dtic.mil/100.2/ADA327082.
Testo completoAbstract (sommario):
Thesis (M.S. in Engineering Acoustics) Naval Postgraduate School, December 1996.Thesis advisor(s): Sanders, J. V.; Atchley, A. A. "December 1996." Includes bibliographical references (p. 215). Also Available online.
6
Melody, Kevin Andrew. "Computer programs supporting instruction in acoustics". Thesis, Monterey, Calif. : Springfield, Va. : Naval Postgraduate School ; Available from National Technical Information Service, 1998. http://handle.dtic.mil/100.2/ADA343632.
Testo completoAbstract (sommario):
Thesis (M.S. in Engineering Acoustics) Naval Postgraduate School, March 1998.Thesis advisor(s): Sanders, James V. "March 1998." Includes bibliographical references (p. 105). Also available online.
7
Givan, Robert Lawrence. "Automatically inferring properties of computer programs". Thesis, Massachusetts Institute of Technology, 1996. http://hdl.handle.net/1721.1/11051.
Testo completoAbstract (sommario):
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1996.Includes bibliographical references (p. 97-101).
by Robert Lawrence Givan, Jr.
Ph.D.
8
Metz, Gale Lynn. "The units of measure consistency checker for the entity-relationship-attribute requirements model". Thesis, Kansas State University, 1986. http://hdl.handle.net/2097/9941.
Testo completo
9
Coleman, Jesse J. "The design, construction, and implementation of an engineering software command processor and macro compiler /". Online version of thesis, 1995. http://hdl.handle.net/1850/12219.
Testo completo
10
Kushman, Nate. "Generating computer programs from natural language descriptions". Thesis, Massachusetts Institute of Technology, 2015. http://hdl.handle.net/1721.1/101572.
Testo completoAbstract (sommario):
Thesis: Ph. D., Massachusetts Institute of Technology, Department of Electrical Engineering and Computer Science, 2015.Cataloged from PDF version of thesis.
Includes bibliographical references (pages 159-169).
This thesis addresses the problem of learning to translate natural language into preexisting programming languages supported by widely-deployed computer systems. Generating programs for existing computer systems enables us to take advantage of two important capabilities of these systems: computing the semantic equivalence between programs, and executing the programs to obtain a result. We present probabilistic models and inference algorithms which integrate these capabilities into the learning process. We use these to build systems that learn to generate programs from natural language in three different computing domains: text processing, solving math problems, and performing robotic tasks in a virtual world. In all cases the resulting systems provide significant performance gains over strong baselines which do not exploit the underlying system capabilities to help interpret the text.
by Nate Kushman.
Ph. D.
11
Jones, Philip E. C. "Common subexpression detection in dataflow programs /". Title page, contents and summary only, 1989. http://web4.library.adelaide.edu.au/theses/09SM/09smj78.pdf.
Testo completo
12
Tibbetts, Tracey D. "Computer generated music : a methodology for computer music composition". Virtual Press, 1999. http://liblink.bsu.edu/uhtbin/catkey/1125059.
Testo completoAbstract (sommario):
This study will prove the fact that computers provide unprecedented opportunities to create music. Several distinct levels of computer participation can exist in the creative process. The lowest level, involving record-keeping functions, results in programs that serve as compositional aids. The intermediate level incorporates stochastic (literally "random") processes on a limited basis, and represents the midpoint between computer-assisted and computercomposed works. The highest level focuses on the design of algorithms that result in compositions determined in most of their details by stochastic processes and computer decision making. Although there is no clear dividing line between levels of computer/composer interaction, it is possible to characterize the degree to which the computer has provided outcomes for a given work, from low-level random generation of pitches to high-level Markovian chain distributions.Department of Computer Science
13
Mareček, Jakub. "Exploiting structure in integer programs". Thesis, University of Nottingham, 2012. http://eprints.nottingham.ac.uk/49276/.
Testo completoAbstract (sommario):
The thesis argues the case for exploiting certain structures in integer linear programs. Integer linear programs are optimisation problems, where one minimises or maximises a linear function of variables, whose values are required to be integral as well as satisfying certain linear equalities and inequalities. For such an abstract problem, there are very good general-purpose solvers. The state of the art in such solvers is an approach known as “branch and bound”. The performance of such solvers depends crucially on four types of in-built heuristics: primal, improvement, branching, and cut-separation or, more generally, bounding heuristics. However, such heuristics have, until recently, not exploited structure in integer linear programs beyond the recognition of certain types of single-row constraints. Many alternative approaches to integer linear programming can be cast in the following, novel framework. “Structure” in any integer linear program is a class of equivalence among triples of algorithms: deriving combinatorial objects from the input, adapting them, and transforming the adapted object to solutions of the original integer linear program. Many such alternative approaches are, however, inherently incompatible with branch and bound solvers. We, hence, define a structure to be “useful”, only when it extracts submatrices, which allow for the implementation of more than one of the four types of heuristics required in the branch and bound approach. Although the extraction of the best possible submatrices is non-trivial, the lack of a considerable submatrix with a given property can often be recognised quickly, and storing useful submatrices in a “pool” makes it possible to use them repeatedly. The goal is to explore whether the state-of-the-art solvers could make use of the structures studied in the academia. Three examples of useful structures in integer linear programs are presented. A particularly widely applicable useful structure relies on the aggregation of variables. Its application can be seen as a decomposition into three stages: Firstly, we partition variables in the original instance into as small number as possible of support sets of constraints forcing convex combinations of binary variables to be less than or equal to one in the original instance, and one-element sets. Secondly, we solve the “aggregated” instance corresponding to the partition of variables. Under certain conditions, we obtain a valid lower bound. Finally, we fix the solution of the aggregated instance in primal and improvement heuristics for the original instance, and use the partition in hyper-plane branching heuristics. Under certain conditions, the primal heuristics are guaranteed to find a feasible solution to the original instance. We also present structures exploiting mutual-exclusion and precedence constraints, prevalent in scheduling and timetabling applications. Mutual exclusion constraints correspond to instances of graph colouring. For numerous extensions of graph colouring, there are natural primal and branching heuristics. We present lower bounding heuristics for extensions of graph colouring, based on augmented Lagrangian methods for novel semidefinite programming relaxations, and reformulations based on a novel transformation of graph colouring to graph multicolouring. Precedence constraints correspond to an instance of precedence-constrained multi-dimensional packing. For such packing problems, we present heuristics based on an adaptive discretisation and strong discretised linear programming relaxations. On in- stances of packing unit-cubes into a box, the reformulation makes it possible to solve instances that are by five orders of magnitude larger than previously. On instances from complex timetabling problems, which combine mutual- exclusion and packing constraints, the combination of heuristics above can often result in the gap between primal and dual bounds being reduced to under five percent, orders of magnitude faster than using state of the art solvers, without any information being used that is outside of the instance.
14
Vaughan-Taylor, Keir. "Geodesy : a geodetic database system". Thesis, The University of Sydney, 1990. https://hdl.handle.net/2123/26339.
Testo completoAbstract (sommario):
Geodesy is a geodetic storage and rendering system designed to retrieve and display textual information, topographic maps and three dimensional underground entities, particularly caves. This paper first overviews the methods of data management in relation to the problems and techniques used in adopting cave survey data as a data source for three dimensional images. It then discusses a method used to generate a three dimensional image from the survey data.
A display package was developed to show surfaces represented as polygons with hidden surface removal for intersecting surfaces and with shading. The approach used was based on standard methodologies but employs a number of new ideas in its mechanism. An extension of Watkins hidden surface algorithm is described which allows the correct rendering of intersecting polygons.
The misclosure problem for Speleological surveys is discussed, a solution proposed and implemented. The story of the Karst Index is overviewed including political and legal implications of its use in this project. The final part of the Geodesy project was to integrate the software modules to run under an operating system within a windowing environment.
15
Marlow, Simon David. "Deforestation for higher-order functional programs". Thesis, University of Glasgow, 1995. http://theses.gla.ac.uk/4818/.
Testo completoAbstract (sommario):
Functional programming languages are an ideal medium for program optimisations based on source-to-source transformation techniques. Referential transparency affords opportunities for a wide range of correctness-preserving transformations leading to potent optimisation strategies. This thesis builds on deforestation, a program transformation technique due to Wadler that removes intermediate data structures from first-order functional programs. Our contribution is to reformulate deforestation for higher-order functional programming languages, and to show that the resulting algorithm terminates given certain syntactic and typing constraints on the input. These constraints are entirely reasonable, indeed it is possible to translate any typed program into the required syntactic form. We show how this translation can be performed automatically and optimally. The higher-order deforestation algorithm is transparent. That is, it is possible to determine by examination of the source program where the optimisation will be applicable. We also investigate the relationship of deforestation to cut-elimination, the normalisation property for the logic of sequent calculus. By combining a cut-elimination algorithm and first-order deforestation, we derive an improved higher-order deforestation algorithm. The higher-order deforestation algorithm has been implemented in the Glasgow Haskell Compiler. We describe how deforestation fits into the framework of Haskell, and design a model for the implementation that allows automatic list removal, with additional deforestation being performed on the basis of programmer supplied annotations. Results from applying the deforestation implementation to several example Haskell programs are given.
16
Collins, Graham Richard McFarlane. "Supporting formal reasoning about functional programs". Thesis, University of Glasgow, 2001. http://theses.gla.ac.uk/4609/.
Testo completoAbstract (sommario):
It is often claimed that functional programming languages, and in particular pure functional languages are suitable for formal reasoning. This claim is supported by the fact that many people in the functional programming community do reason about languages and programs in a formal or semi-formal way. Different reasoning principles such as equational reasoning, induction and co-induction, are used, depending on the nature of the problem. Using a computer program to check the application of rules and to mechanise the tedious bookkeeping involved can simplify proofs and provide more confidence in their correctness. When reasoning about programs, this can also allow experiments with new rules and reasoning styles, where a user may not be confident about structuring a proof on paper. Checking the applicability of a rule can eliminate the risk of mistakes caused by misunderstanding the theory being used. Just as there are different ways in which formal or informal reasoning can be applied in functional programming, there are different ways in which tools can be provided to support this reasoning. This thesis describes an investigation of how to develop a mechanised reasoning system to allow reasoning about algorithms as a functional programmer would write them, not an encoding of the algorithm into a significantly different form. In addition, this work aims to develop a system to support a user who is not a theorem proving expert or an expert in the theoretical foundations of functional programming. The work is aimed towards a system that could be used by a functional programmer developing real programs and wishing to prove some or all of the programs correct or to prove that two programs are equivalent.
17
Veeder, Nadine M. "An exploratory study of software development measures across COBOL programs". Thesis, Kansas State University, 1986. http://hdl.handle.net/2097/9977.
Testo completo
18
Illsley, Martin. "Transforming imperative programs". Thesis, University of Edinburgh, 1988. http://hdl.handle.net/1842/10973.
Testo completo
19
Chen, Mei 1962. "The characterization of learning environments and program structures of instructional programs produced using Logo /". Thesis, McGill University, 1992. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=56930.
Testo completoAbstract (sommario):
A methodology was developed in this study for identifying the cognitive, pedagogical, and computational characteristics of computer-based learning environments. The characterization of the cognitive and pedagogical features was achieved by decomposing the learning environments into episodes which were composed of sequences of "views". Each "view" was described in terms of the different types of knowledge presented, the pedagogical strategies used to present the knowledge, and the forms and functions of user-computer interactions elicited. The computational characteristics were described in terms of modularity and other programming properties. The methodology was applied to characterizing the instructional programs produced by student teachers using Logo.The results showed that this methodology can successfully identify the cognitive, pedagogical and computational characteristics of the learning environments. It can also clarify what can be learned in a microworld, especially the "powerful ideas" in Logo environments. In addition, the usability and constraints of learning environments in meeting the learners' cognitive needs during the learning process can be assessed.
20
Anderson, Steven Schuyler. "Is there a shortage of computer programmers/systems analysts? an examination of the empirical evidence /". Thesis, Monterey, California : Naval Postgraduate School, 1990. http://handle.dtic.mil/100.2/ADA240588.
Testo completoAbstract (sommario):
Thesis (M.S. in Information Systems)--Naval Postgraduate School, September1990.Thesis Advisor(s): Haga, William J. Second Reader: Mehay, Stephen L. "September 1990." Description based on title screen viewed on December 16, 2009. DTIC Descriptor(s): Computer personnel, shortages, programmers, analysts, systems analysis, theses, computers, specialists. DTIC Identifier(s): Computer programs, systems analysis, specialists, shortages, theses. Author(s) subject terms: Programmer, systems analysis, shortage, shortfall. Includes bibliographical references (p. 29-30). Also available in print.
21
Xia, Ying Han. "Establishing trust in encrypted programs". Diss., Atlanta, Ga. : Georgia Institute of Technology, 2008. http://hdl.handle.net/1853/24761.
Testo completoAbstract (sommario):
Thesis (Ph.D.)--Electrical and Computer Engineering, Georgia Institute of Technology, 2009.Committee Chair: Owen, Henry; Committee Co-Chair: Abler, Randal; Committee Member: Copeland, John; Committee Member: Giffin, Jon; Committee Member: Hamblen, Jim.
22
Allemang, Dean T. "Understanding programs as devices /". The Ohio State University, 1990. http://rave.ohiolink.edu/etdc/view?acc_num=osu1487676261012487.
Testo completo
23
Quigley, Claire Louise. "A programming logic for Java bytecode programs". Thesis, University of Glasgow, 2004. http://theses.gla.ac.uk/3030/.
Testo completoAbstract (sommario):
One significant disadvantage of interpreted bytecode languages, such as Java, is their low execution speed in comparison to compiled languages like C. The mobile nature of bytecode adds to the problem, as many checks are necessary to ensure that downloaded code from untrusted sources is rendered as safe as possible. But there do exist ways of speeding up such systems. One approach is to carry out static type checking at load time, as in the case of the Java Bytecode Verifier. This reduces the number of runtime checks that must be done and also allows certain instructions to be replaced by faster versions. Another approach is the use of a Just In Time (JIT) Compiler, which takes the bytecode and produces corresponding native code at runtime. Some JIT compilers also carry out some code optimization. There are, however, limits to the amount of optimization that can safely be done by the Verifier and JITs; some operations simply cannot be carried out safely without a certain amount of runtime checking. But what if it were possible to prove that the conditions the runtime checks guard against would never arise in a particular piece of code? In this case it might well be possible to dispense with these checks altogether, allowing optimizations not feasible at present. In addition to this, because of time constraints, current JIT compilers tend to produce acceptable code as quickly as possible, rather than producing the best code possible. By removing the burden of analysis from them it may be possible to change this. We demonstrate that it is possible to define a programming logic for bytecode programs that allows the proof of bytecode programs containing loops. The instructions available to use in the programs are currently limited, but the basis is in place to extend these. The development of this logic is non-trivial and addresses several difficult problems engendered by the unstructured nature of bytecode programs.
24
Handa, Sunny. "Reverse engineering computer programs under Canadian copyright law". Thesis, McGill University, 1994. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=22693.
Testo completoAbstract (sommario):
The field of copyright law has been especially active in recent times as a result of its application to computer programs. Copyright law, not originally designed to protect such works, has had to adapt to suit the special nature of computer programs. This paper addresses the applicability of copyright law to the reverse engineering of computer programs. Reverse engineering is a method by which programmers may uncover the ideas and processes used within an existing computer program, thereby allowing the construction of compatible computer programs. Reverse engineering may also be used to create works which are directly competitive with the original program, and may also be used to assist in the piracy of computer programs. The mere act of reverse engineering computer programs, regardless of its purpose, potentially infringes the copyright of the computer program in question, notwithstanding whether the results of the process are used in an infringing manner.Recently both the European Union countries and the United States have accepted reverse engineering as an exception to copyright infringement. The European Union has opted for a legislative solution, whereas in the United States several courts have construed the fair use exception contained in that country's Copyright Act as allowing reverse engineering.
In this paper, it is argued that Canada must also adopt a reverse engineering exception to copyright infringement. It is claimed that the implementation of such an exception is justified through examination of the underlying policy goals of copyright law in the context of an economic framework. Reverse engineering fosters the creation of standards which, it is argued, increase societal wealth. The existence of a reverse engineering exception is consistent with the balance between the economic rights of individual authors and societal technological progress, which copyright seeks to maintain. It is demonstrated that copyright exists as the only form of applicable intellectual property protection which can broadly limit the disclosure of concepts underlying computer programs.
It is suggested that an effective exception should be statutorily based. It is felt that the existing fair dealing exception contained in the Canadian Copyright Act is juridically under-developed and too uncertain to provide an effective solution to the reverse engineering problem. A legislative solution would send a clear message to the software industry as well as to the courts, and could prohibit contracting out of the Copyright Act which would potentially be allowed were a judicial solution sought. It is further suggested that the statutory exception should broadly allow the process of reverse engineering as opposed to limiting it to cases where compatibility is sought. Narrowing the exception creates conceptual difficulties in applying limits to reverse engineering. Allowing a broad exception would avoid these difficulties while continuing to provide copyright holders with protection if, after the reverse engineering process is concluded, their protectable expression is used within another's software product.
25
MacAllister, Craig M. "Computer graphics adaptation of several aerodynamic prediction programs". Thesis, Monterey, California. Naval Postgraduate School, 1989. http://hdl.handle.net/10945/25766.
Testo completo
26
Murphy, Kieran Gerard. "Parallelization of the atomic R-matrix computer programs". Thesis, Queen's University Belfast, 1993. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.333825.
Testo completo
27
Schroeder, Deborah. "Development of computer programs to aid synthesis planning". Thesis, University of Leeds, 1989. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.329976.
Testo completo
28
Tanteri, E. "Analysis of computer programs for modeling casting processes". Thesis, Київський національний університет технологій та дизайну, 2019. https://er.knutd.edu.ua/handle/123456789/14621.
Testo completo
29
Alshammari, Bandar M. "Quality metrics for assessing security-critical computer programs". Thesis, Queensland University of Technology, 2011. https://eprints.qut.edu.au/49780/1/Bandar_Alshammari_Thesis.pdf.
Testo completoAbstract (sommario):
Existing secure software development principles tend to focus on coding vulnerabilities, such as buffer or integer overflows, that apply to individual program statements, or issues associated with the run-time environment, such as component isolation. Here we instead consider software security from the perspective of potential information flow through a program’s object-oriented module structure. In particular, we define a set of quantifiable "security metrics" which allow programmers to quickly and easily assess the overall security of a given source code program or object-oriented design. Although measuring quality attributes of object-oriented programs for properties such as maintainability and performance has been well-covered in the literature, metrics which measure the quality of information security have received little attention. Moreover, existing securityrelevant metrics assess a system either at a very high level, i.e., the whole system, or at a fine level of granularity, i.e., with respect to individual statements. These approaches make it hard and expensive to recognise a secure system from an early stage of development. Instead, our security metrics are based on well-established compositional properties of object-oriented programs (i.e., data encapsulation, cohesion, coupling, composition, extensibility, inheritance and design size), combined with data flow analysis principles that trace potential information flow between high- and low-security system variables. We first define a set of metrics to assess the security quality of a given object-oriented system based on its design artifacts, allowing defects to be detected at an early stage of development. We then extend these metrics to produce a second set applicable to object-oriented program source code. The resulting metrics make it easy to compare the relative security of functionallyequivalent system designs or source code programs so that, for instance, the security of two different revisions of the same system can be compared directly. This capability is further used to study the impact of specific refactoring rules on system security more generally, at both the design and code levels. By measuring the relative security of various programs refactored using different rules, we thus provide guidelines for the safe application of refactoring steps to security-critical programs. Finally, to make it easy and efficient to measure a system design or program’s security, we have also developed a stand-alone software tool which automatically analyses and measures the security of UML designs and Java program code. The tool’s capabilities are demonstrated by applying it to a number of security-critical system designs and Java programs. Notably, the validity of the metrics is demonstrated empirically through measurements that confirm our expectation that program security typically improves as bugs are fixed, but worsens as new functionality is added.
30
Librers, Joseph. "A module declaration generator". Thesis, Kansas State University, 1985. http://hdl.handle.net/2097/9861.
Testo completo
31
Vemuri, Suresh P. "Jedit : a graph editor in Java". Virtual Press, 1996. http://liblink.bsu.edu/uhtbin/catkey/1036185.
Testo completoAbstract (sommario):
There are increasing demands for graphics-oriented software packages for graph theory teaching and research. G-Net, a departmental research project headed by Dr. Jay Bagga, is an effort to create a software package that comprises of a graph database, a graph editor, 'and a collection of graph algorithms. Also, with widespread use of the World Wide Web, the graph editor should be accessible through the Web. Taking these issues into consideration Jedit (Java Graph editor) is developed. This thesis concentrates on the design and implementation of a graph editor and a graph object (Jgraph). Jgraph is developed in java to implement the graph algorithms in future. One of the unique features of this graph editor is that it can be used as stand-alone application or as an applet for the Web. In addition, it also provides a friendly user interface.Department of Computer Science
32
Florez-Larrahondo, German. "A trusted environment for MPI programs". Master's thesis, Mississippi State : Mississippi State University, 2002. http://library.msstate.edu/etd/show.asp?etd=etd-10172002-103135.
Testo completo
33
Hackett, James Simpson. "An economic analysis of multiple use forestry using FORPLAN-Version 2". Thesis, University of British Columbia, 1989. http://hdl.handle.net/2429/29033.
Testo completoAbstract (sommario):
This thesis examines a mathematical programming model called FORPLAN as a planning
tool for strategic analysis of forest management alternatives. This model uses economic efficiency as the objective of forest management planning.
The dynamic theory of multiple use forestry is analyzed and expressed as a linear programming
analogue in FORPLAN. The main weakness of this theory is that it focuses on single stand analysis. Even so, forest wide constraints applied to certain FORPLAN formulations compensate for this weakness.
A strata-based forest management problem is developed to show the economic implications
of four forest management alternatives: (1) timber production; (2) timber production subject to a non-declining yield limitation; (3) timber and black-tailed deer (Odocolieus hemionus columbianus) production; and (4) timber and black-tailed deer production, again including a non-declining yield of timber.
Demand curves for two analysis areas and a supply curve for deer winter range are developed using parametric analysis.
The ability of FORPLAN to address economic implications of current forest management
policies is discussed. Economic analysis of forest management alternatives would play a useful role in forest planning in British Columbia. The need for such evaluation is underlined by the ever increasing number of resource conflicts caused by the dominance of the timber industry and the continually growing demand for other forest resources.
Three conclusions are drawn from this study. First, FORPLAN has the technical capability
to be an effective tool for analyzing strategic multiple use plans under economic efficiency criteria. It does not have the timber bias of earlier models and the capability of FORPLAN to
integrate area and strata-based variables makes it a very powerful model.
Second, parametric programming of FORPLAN solutions provides marginal analysis for inputs and outputs. Comparative examination of these curves and their elasticities provide information about the relative importance of different analysis areas.
Lastly, managing for timber and hunting services for black-tailed deer by preserving old growth winter range is not an economically viable management option. The relative value of the timber is significantly greater than the hunting services for the deer that it is just not worth managing for both.Forestry, Faculty of
Graduate
34
Naeem, Nomair A. "Programmer-friendly decompiled Java". Thesis, McGill University, 2006. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=101644.
Testo completoAbstract (sommario):
Java decompilers convert Java class files to Java source. Common Java decompilers are javac-specific decompilers since they target bytecode produced from a particular javac compiler. We present work carried out on Dava, a tool-independent decompiler that decompiles bytecode produced from any compiler. A known deficiency of tool-independent decompilers is the generation of complicated decompiled Java source which does not resemble the original source as closely as output produced by javac-specific decompilers. This thesis tackles this short-coming, for Dava, by introducing a new back-end consisting of simplifying transformations.The work presented can be broken into three major categories: transformations using tree traversals and pattern matching to simplify the control flow, the creation of a flow analysis framework for an Abstract Syntax Tree (AST) representation of Java source code and the implementation of flow analyses with their use in complicated transformations.
The pattern matching transformations rewrite the ASTs to semantically-equivalent ASTs that correspond to code that is easier for programmers to understand. The targeted Java constructs include If and If-Else aggregation, for-loop creation and the removal of abrupt control flow. Pattern matching using tree traversals has its limitations. Thus, we introduce a new structure-based data flow analysis framework that can be used to gather information required by more complex transformations. Popular compiler analyses e.g., reaching definitions, constant propagation etc. were implemented using the framework. Information from these analyses is then leveraged to perform more advanced AST transformations.
We performed experiments comparing different decompiler outputs for different sources of bytecode. The results from these experiments indicate that the new Dava back-end considerably improves code comprehensibility and readability.
35
O'Bagy, Janalee. "The implementation of generators and goal-directed evaluation in Icon". Diss., The University of Arizona, 1988. http://hdl.handle.net/10150/184491.
Testo completoAbstract (sommario):
Generators and goal-directed evaluation provide a rich programming paradigm when combined with traditional control structures in an imperative language. Icon is a language whose goal-directed evaluation is integrated with traditional control structures. This integration provides powerful mechanisms for formulating many complex programming operations in concise and natural ways. However, generators, goal-directed evaluation, and related control structures introduce implementation problems that do not exist for languages with only conventional expression evaluation. This dissertation presents an implementation model using recursion that serves as a basis for both an interpreter and a compiler. Furthermore, in the case of the compiler, optimizations can be performed to improve the efficiency of Icon programs, mainly by reducing the general evaluation strategy whenever possible. The dissertation describes a compile-time semantic analysis used to gather information about the properties of expressions and how they are used at their lexical sites. The optimizations that can be performed using this information are illustrated in the context of the compiler model described in the dissertation.
36
Nikolik, Borislav. "Data Dependence in Programs Involving Indexed Variables". PDXScholar, 1993. https://pdxscholar.library.pdx.edu/open_access_etds/4688.
Testo completoAbstract (sommario):
Symbolic execution is a powerful technique used to perform various activities such as program testing, formal verification of programs, etc. However, symbolic execution does not deal with indexed variables in an adequate manner. Integration of indexed variables such as arrays into symbolic execution would increase the generality of this technique. We present an original substitution technique that produces array-term-free constraints as a counterargument to the commonly accepted belief that symbolic execution cannot handle arrays. The substitution technique deals with constraints involving array terms with a single aggregate name, array terms with multiple aggregate names, and nested array terms. Our approach to solving constraints involving array terms is based on the analysis of the relationship between the array subscripts. Dataflow dependence analysis of programs involving indexed variables suffers from problems of undecidability. We propose a separation technique in which the array subscript constraints are separated from the loop path constraints. The separation technique suggests that the problem of establishing data dependencies is not as hard as the general loop problem. In this respect, we present a new general heuristic program analysis technique which is used to preserve the properties of the relations between program variables.
37
Muqtadir, Abdul. "Real-time finance management system". CSUSB ScholarWorks, 2006. https://scholarworks.lib.csusb.edu/etd-project/2992.
Testo completoAbstract (sommario):
Discusses the development of a real-time finance management system (RFMS) computer application. RFMS lets users learn about and manage their personal finances and stock portfolio. Finances can be managed using management tools and calculators. The program uses a Java/XML based approach where real-time market data from different stock exchanges is fetched and displayed for the user. Stock performance can then be graphed.
38
Kong, Yow Wai. "Computer aided design of composite beams". Thesis, McGill University, 1985. http://digitool.Library.McGill.CA:80/R/?func=dbin-jump-full&object_id=63364.
Testo completo
39
Keating, Marla Jo Matlick. "Computers in college art and design programs /". Online version of thesis, 1992. http://hdl.handle.net/1850/11630.
Testo completo
40
Wendt, N. Rodney. "Applications of program understanding and rule-based quality assurance to Slam II simulation programs". Thesis, University of Ottawa (Canada), 1993. http://hdl.handle.net/10393/6893.
Testo completoAbstract (sommario):
With the advance of time, our inventory of simulation programs has and continues to accumulate. To maximize the return on our investment of time and money into these software systems, it is advantageous for us to reuse software components as much as possible. For example, previously engineered simulation models can often be reused and exercised under a new set of experimental conditions. Before a software component can be reused, the analyst must learn and understand its functionality. This learning process is often made unnecessarily difficult due to incomplete documentation. Another contributing factor is the complexity brought about by interacting directly with the program code. Furthermore, when it comes time to make updates to the code, the potential arises for semantic and syntactic errors to work their way into the program. Knowledge-based program understanding systems with built in quality assurance can be used as an environment for simplifying the learning and the update processes, while ensuring an acceptable degree of quality has been maintained during the update process. This thesis discusses program understanding and quality assurance issues related to the Slam II programming language and discusses the architecture of E/Slam (Elucidation of Slam II programs). E/Slam is a knowledge-based program understanding system with built-in quality assurance ability.
41
Challa, Varshi. "Accessing timesheets via internet through ASP and ODBC". CSUSB ScholarWorks, 2000. https://scholarworks.lib.csusb.edu/etd-project/1605.
Testo completoAbstract (sommario):
The purpose of this project is to develop a computerized timesheet application. Using this application, an employee of a company can log onto the company's Web site and fill out a timesheet from anywhere in the world. The project involved automating timesheet data entry and approval procedures using contemporary technologies like Active Server Pages (ASP), JavaScript, VB Script, Component Object Model (COM), Components and Open Database connectivity (ODBC).
42
Deighan, John. "VPI PROLOG compiler project report". Master's thesis, This resource online, 1991. http://scholar.lib.vt.edu/theses/available/etd-01262010-020109/.
Testo completo
43
Ellis, Jason Benjamin. "Palaver tree online : technological support for classroom integration of Oral History". Diss., Georgia Institute of Technology, 2003. http://hdl.handle.net/1853/9189.
Testo completo
44
Tang, Dezheng. "Mapping Programs to Parallel Architectures in the Real World". PDXScholar, 1992. https://pdxscholar.library.pdx.edu/open_access_etds/4534.
Testo completoAbstract (sommario):
Mapping an application program to a parallel architecture can be described as a multidimensional optimization problem. To simplify the problem, we divide the overall mapping process into three sequential substeps: partitioning, allocating, and scheduling, with each step using a few details of the program and architecture description. Due to the difficulty in accurately describing the program and architecture and the fact that each substep uses incomplete information, inaccuracy is pervasive in the real-world mapping process. We hypothesize that the inaccuracy and the use of suboptimal, heuristic mapping methods may greatly affect the mapping or submapping performance and lead to a non-optimal solution. We do not discard the typical approach used by most researchers in which total execution time or speedup is the criterion to evaluate the quality of the mapping. However, we improve on this approach by including the effects of inaccuracy. We believe that, due to the presence of inaccuracy in the mapping process, investigating the impact of inaccuracy on the mapping quality is crucial to achieving good mappings. The motivation of this work is to identify the various inaccuracies during the mapping procedure and explore the sensitivity of mapping quality to the inaccurate parameters. To conduct the sensitivity examination, the Global Cluster partitioning algorithm and some models were used. The models use some program and architecture characteristics, or lower-level meters, to characterize the mapping solution space. The algorithm searches the solution space and makes the decision based on the information provided by the models. The experiments were implemented on a UNIX LAN of Sun workstations for different data flow graphs. The graphs use three parallel programming paradigms: fine grained, coarse-grained, and pipelined styles, to represent some high-level application programs: vector inner product calculation, matrix multiplication, and Gaussian elimination respectively. The experimental results show that varying system behavior affects the accuracy of lower-level meters, and the quality of the mapping algorithm is very sensitive to the inaccuracies.
45
Bartenstein, Thomas W. "Rate Types for Stream Programs". Thesis, State University of New York at Binghamton, 2017. http://pqdtopen.proquest.com/#viewpdf?dispub=10643063.
Testo completoAbstract (sommario):
RATE TYPES is a novel type system to reason about and optimize data-intensive programs. Built around stream languages, RATE TYPES performs static quantitative reasoning about stream rates—the frequency of data items in a stream being consumed, processed, and produced. Despite the fact that streams are fundamentally dynamic, there are two essential concepts of stream rate control—throughput ratio and natural rate—which are intimately related to the program structure itself and can be effectively reasoned about by a type system. RATE TYPES is proven to correspond with a timeaware operational semantics which supports parallelism. The strong correspondence result tolerates arbitrary schedules, and does not require any synchronization between stream filters. RATE TYPES is also implemented on stream programs, demonstrating its effectiveness in predicting stream data rates in real-world stream programs. Applications of RATE TYPES are discussed, including an application of RATE TYPES to optimize energy consumption.
46
Lapointe, Stéphane. "Induction of recursive logic programs". Thesis, University of Ottawa (Canada), 1992. http://hdl.handle.net/10393/7467.
Testo completo
47
Wassell, Mark P. "Semantic optimisation in datalog programs". Master's thesis, University of Cape Town, 1990. http://hdl.handle.net/11427/13556.
Testo completoAbstract (sommario):
Bibliography: leaves 138-142.Datalog is the fusion of Prolog and Database technologies aimed at producing an efficient, logic-based, declarative language for databases. This fusion takes the best of logic programming for the syntax of Datalog, and the best of database systems for the operational part of Datalog. As is the case with all declarative languages, optimisation is necessary to improve the efficiency of programs. Semantic optimisation uses meta-knowledge describing the data in the database to optimise queries and rules, aiming to reduce the resources required to answer queries. In this thesis, I analyse prior work that has been done on semantic optimisation and then propose an optimisation system for Datalog that includes optimisation of recursive programs and a semantic knowledge management module. A language, DatalogiC, which is an extension of Datalog that allows semantic knowledge to be expressed, has also been devised as an implementation vehicle. Finally, empirical results concerning the benefits of semantic optimisation are reported.
48
Lloyd, William Samuel. "Causal reasoning about distributed programs". W&M ScholarWorks, 1991. https://scholarworks.wm.edu/etd/1539623806.
Testo completoAbstract (sommario):
We present an integrated approach to the specification, verification and testing of distributed programs. We show how "global" properties defined by transition axiom specifications can be interpreted as definitions of causal relationships between process states. We explain why reasoning about causal rather than global relationships yields a clearer picture of distributed processing.;We present a proof system for showing the partial correctness of CSP programs that places strict restrictions on assertions. It admits no global assertions. A process annotation may reference only local state. Glue predicates relate pairs of process states at points of interprocess communication. No assertion references auxiliary variables; appropriate use of control predicates and vector clock values eliminates the need for them. Our proof system emphasizes causality. We do not prove processes correct in isolation. We instead track causality as we write our annotations. When we come to a send or receive, we consider all the statements that could communicate with it, and use the semantics of CSP message passing to derive its postcondition. We show that our CSP proof system is sound and relatively complete, and that we need only recursive assertions to prove that any program in our fragment of CSP is partially correct. Our proof system is, therefore, as powerful as other proof systems for CSP.;We extend our work to develop proof systems for asynchronous communication. For each proof system, our motivation is to be able to write proofs that show that code satisfies its specification, while making only assertions we can use to define the aspects of process state that we should trace during test runs, and check during postmortem analysis. We can trace the assertions we make without having to modify program code or add synchronization or message passing.;Why, if we verify correctness, would we want to test? We observe that a proof, like a program, is susceptible to error. By tracing and analyzing program state during testing, we can build our confidence that our proof is valid.
49
Calnan, Paul W. "EXTRACT, Extensible Transformation and Compiler Technology". Link to electronic thesis, 2003. http://www.wpi.edu/Pubs/ETD/Available/etd-0429103-152947.
Testo completo
50
Wendelborn, Andrew Lawrence. "Data flow implementations of a lucid-like programming language". Title page, contents and summary only, 1985. http://web4.library.adelaide.edu.au/theses/09PH/09phw471.pdf.
Testo completo