Relevant bibliographies by topics / Programs with pointers

Contents

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

Academic literature on the topic 'Programs with pointers'

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

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

Select a source type:

Consult the lists of relevant articles, books, theses, conference reports, and other scholarly sources on the topic 'Programs with pointers.'

Next to every source in the list of references, there is an 'Add to bibliography' button. Press on it, and we will generate automatically the bibliographic reference to the chosen work in the citation style you need: APA, MLA, Harvard, Chicago, Vancouver, etc.

You can also download the full text of the academic publication as pdf and read online its abstract whenever available in the metadata.

Journal articles on the topic "Programs with pointers"

1

Møller, Anders. "Verifying Programs that Manipulate Pointers." Electronic Notes in Theoretical Computer Science 98 (August 2004): 3–4. http://dx.doi.org/10.1016/j.entcs.2003.10.002.

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

Amme, Wolfram, and Eberhard Zehendner. "Data dependence analysis in programs with pointers." Parallel Computing 24, no. 3-4 (May 1998): 505–25. http://dx.doi.org/10.1016/s0167-8191(98)00023-4.

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

Eisenbarth, Thomas, Rainer Koschke, and Gunther Vogel. "Static object trace extraction for programs with pointers." Journal of Systems and Software 77, no. 3 (September 2005): 263–84. http://dx.doi.org/10.1016/j.jss.2004.04.028.

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

Milanova, Ana, Atanas Rountev, and Barbara G. Ryder. "Precise Call Graphs for C Programs with Function Pointers." Automated Software Engineering 11, no. 1 (January 2004): 7–26. http://dx.doi.org/10.1023/b:ause.0000008666.56394.a1.

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

Shelekhov, V. I. "Applying Program Transformations for Deductive Verification of the List Reverse Program." Programmnaya Ingeneria 12, no. 3 (May 19, 2021): 127–39. http://dx.doi.org/10.17587/prin.12.127-139.

Full text
Abstract:
The program transformation methods to simplify the deductive verification of programs with recursive data types are investigated. The list reversion program is considered as an example. A source program in the C language is translated to the cP functional language which includes no pointers. The resulting program is translated further to the WhyML language to perform deductive verification of the program. The cP language includes the same constructs of the C language except pointers. In the C program, all actions that include pointers are replaced by the equivalent fragments without pointers. These replacement are performed by the special transformations using the results of the program dataflow analysis. Three variants of deductive verification of the transformed list reverse program in the Why3 verification platform with SMT solvers (Z3 4.8.6, CVC3 2.4.1, CVC4 1.7) are performed. First, the recursive WhyML program supplied with specifications was automatically verified successfully using only SMT solvers. Second, the recursive program was translated to the P predicate language. Correctness formulae were constructed for the P program and translated further to the why3 specification language. The formulae proving correctness were easy like the first variant. But correctness formulae for the first and second variants were different. Third, the "imperative" WhyML program that included while loop with additional invariant specifications was verified. The proving was easy but not automatic. So, for deductive verification, recursive program variant appears to be more preferable against imperative program variant.
APA, Harvard, Vancouver, ISO, and other styles
6

Halpern, Leslie F. "Some Pointers for Students Interested in Applying to Graduate Programs in Clinical Psychology." Eye on Psi Chi Magazine 6, no. 2 (2002): 21–23. http://dx.doi.org/10.24839/1092-0803.eye6.2.21.

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

Chung, In-Sang. "Automated Test Data Generation for Testing Programs with Multi-level Stack-directed Pointers." KIPS Transactions:PartD 17D, no. 4 (August 31, 2010): 297–310. http://dx.doi.org/10.3745/kipstd.2010.17d.4.297.

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

Livshits, V. Benjamin, and Monica S. Lam. "Tracking pointers with path and context sensitivity for bug detection in C programs." ACM SIGSOFT Software Engineering Notes 28, no. 5 (September 2003): 317–26. http://dx.doi.org/10.1145/949952.940114.

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

Watanabe, Yasunari, Kiran Gopinathan, George Pîrlea, Nadia Polikarpova, and Ilya Sergey. "Certifying the synthesis of heap-manipulating programs." Proceedings of the ACM on Programming Languages 5, ICFP (August 22, 2021): 1–29. http://dx.doi.org/10.1145/3473589.

Full text
Abstract:
Automated deductive program synthesis promises to generate executable programs from concise specifications, along with proofs of correctness that can be independently verified using third-party tools. However, an attempt to exercise this promise using existing proof-certification frameworks reveals significant discrepancies in how proof derivations are structured for two different purposes: program synthesis and program verification. These discrepancies make it difficult to use certified verifiers to validate synthesis results, forcing one to write an ad-hoc translation procedure from synthesis proofs to correctness proofs for each verification backend. In this work, we address this challenge in the context of the synthesis and verification of heap-manipulating programs. We present a technique for principled translation of deductive synthesis derivations (a.k.a. source proofs) into deductive target proofs about the synthesised programs in the logics of interactive program verifiers. We showcase our technique by implementing three different certifiers for programs generated via SuSLik, a Separation Logic-based tool for automated synthesis of programs with pointers, in foundational verification frameworks embedded in Coq: Hoare Type Theory (HTT), Iris, and Verified Software Toolchain (VST), producing concise and efficient machine-checkable proofs for characteristic synthesis benchmarks.
APA, Harvard, Vancouver, ISO, and other styles
10

Atto, Muhsin H. "Graph Inclusion and Matching Algorithms for Programs Manipulating Singly linked Heaps." Science Journal of University of Zakho 9, no. 1 (March 30, 2021): 30–37. http://dx.doi.org/10.25271/sjuoz.2021.9.1.778.

Full text
Abstract:
Programs that manipulate heaps such as singlylinked lists, doublylinked lists, skiplists, and treesare ubiquitous, and hence ensuring their correctness is of utmost importance. Analysing correctness properties for such programs is not trivial since they induce dynamic data structures, leading to unbounded state spaces with intricate patterns. One approach that has been adopted to tackle this problem is the use of symbolic searching techniques. The state space is encoded using graphs where the nodes represent memory cells, and the edges represent pointers between the cells. It is necessary to prune the search to avoid generating massive numbers of graphs, thus making the procedure unpractical. Pruning strategies are defined based on operations such as graph matching and inclusion. In this paper, a set of algorithms for performing these operations are presented. It is demonstrated that the proposed algorithms can handle typical graphs that arise in the verification of heap manipulating programs.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Dissertations / Theses on the topic "Programs with pointers"

1

Liang, Donglin. "Developing practical program analyses for programs with pointers." Diss., Georgia Institute of Technology, 2002. http://hdl.handle.net/1853/8203.

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

Tafat, Asma. "Preuves par raffinement de programmes avec pointeurs." Phd thesis, Université Paris Sud - Paris XI, 2013. http://tel.archives-ouvertes.fr/tel-00874679.

Full text
Abstract:
Le but de cette thèse est de spécifier et prouver des programmes avec pointeurs, tels que des programmes C, en utilisant des techniques de raffinement. L'approche proposée permet de faire un compromis entre les techniques complexes qui existent dans la littérature et ce qui est utilisable dans l'industrie, en conciliant légèreté des annotations et restrictions sur les alias. Nous définissons, dans un premier temps, un langage d'étude, qui s'inspire du langage C, et dans lequel le seul type de données mutable possible est le type des structures, auquel on accède uniquement à travers des pointeurs. Afin de structurer nos programmes, nous munissons notre langage d'une notion de module et des concepts issus de la théorie du raffinement tels que les variables abstraites que nous formalisons par des champs modèle, et les invariants de collage. Ceci nous permet d'écrire des programmes structurés en composants. L'introduction des invariants de données dans notre langage soulève des problématiques liées au partage de pointeurs. En effet, en cas d'alias, on risque de ne plus pouvoir garantir la validité de l'invariant de données d'une structure. Nous interdisons, alors l'aliasing (le partage de référence) dans notre langage. Pour contrôler les accès à la mémoire, nous définissons un système de type, basé sur la notion de régions. Cette contribution s'inspire de la théorie du raffinement et a pour but, de rendre les programmes les plus modulaires possible et leurs preuves les plus automatiques possible. Nous définissons, sur ce langage, un mécanisme de génération d'obligations de preuve en proposant un calcul de plus faible précondition incorporant du raffinement. Nous prouvons ensuite, la correction de ce mécanisme de génération d'obligations de preuve par une méthode originale, fondée sur la notion de sémantique bloquante, qui s'apparente à une preuve de type soundness et qui consiste donc, à prouver la préservation puis le progrès de ce calcul. Nous étendons, dans un deuxième temps, notre langage en levant partiellement la restriction liée au partage de références. Nous permettons, notamment, le partage de références lorsqu'aucun invariant de données n'est associé au type structure référencé. De plus, nous introduisons le type des tableaux, ainsi que les variables globales et l'affectation qui ne font pas partie du langage noyau. Pour chacune des extensions citées ci-dessus, nous étendons la définition et la preuve de correction du calcul de plus faible précondition en conséquence. Nous proposons enfin, une implantation de cette approche sous forme d'un greffon de Frama-C (http://frama-c.com/). Nous expérimentons notre implantation sur des exemples de modules implantant des structures de données complexes, en particulier des défis issus du challenge VACID0 (http://vacid. codeplex.com/), à savoir les tableaux creux (Sparse Array) et les tas binaires.
APA, Harvard, Vancouver, ISO, and other styles
3

Muehlberg, Jan Tobias. "Model checking pointer safety in compiled programs." Thesis, University of York, 2009. http://etheses.whiterose.ac.uk/841/.

Full text
Abstract:
This thesis introduces a novel technique for the automated analysis of compiled programs, which is focused on, but not restricted to, pointer safety properties. Our approach, which we refer to as Symbolic Object Code Analysis (SOCA), employs bounded symbolic execution, and uses an SMT solver as execution and verification engine. Analysing the object code enables us to bypass limitations of other software model checkers with respect to the accepted input language, so that analysing code sections written in inline assembly does not represent a barrier for us. Our technique is especially designed for programs employing complex heap-allocated data structures and provides full counterexample paths for each error found. In difference to other verification techniques, our approach requires only a bare minimum of manual modelling efforts. While generating counterexamples is often impossible for static analysis techniques due to precision loss in join and widening operations, traditional model checking requires the manual construction of models or the use of techniques such as predicate abstraction which do not work well in the presence of heap-allocated data structures. Hence, symbolic execution is our method of choice over static analysis and model checking. We also present the SOCA Verifier as a prototypical implementation of our technique. We show that the SOCA Verifier performs competitively with state-of-the-art software model checkers with respect to error detection and false positive rates. Despite only employing path-sensitive and heap-aware program slicing, the SOCA Verifier is further shown to scale well in an extensive evaluation using 250 Linux device drivers. An in-depth case study on the Linux Virtual File System illustrates that the SOCA technique can be applied to verify program properties beyond pointer safety. Our evaluation testifies SOCA's suitability as an effective and efficient bug-finding tool.
APA, Harvard, Vancouver, ISO, and other styles
4

Luo, Chenguang. "Verification of pointer-based programs with partial information." Thesis, Durham University, 2011. http://etheses.dur.ac.uk/578/.

Full text
Abstract:
The proliferation of software across all aspects of people's life means that software failure can bring catastrophic result. It is therefore highly desirable to be able to develop software that is verified to meet its expected specification. This has also been identified as a key objective in one of the UK Grand Challenges (GC6) (Jones et al., 2006; Woodcock, 2006). However, many difficult problems still remain in achieving this objective, partially due to the wide use of (recursive) shared mutable data structures which are hard to keep track of statically in a precise and concise way. This thesis aims at building a verification system for both memory safety and functional correctness of programs manipulating pointer-based data structures, which can deal with two scenarios where only partial information about the program is available. For instance the verifier may be supplied with only partial program specification, or with full specification but only part of the program code. For the first scenario, previous state-of-the-art works (Nguyen et al., 2007; Chin et al., 2007; Nguyen and Chin, 2008; Chin et al, 2010) generally require users to provide full specifications for each method of the program to be verified. Their approach seeks much intellectual effort from users, and meanwhile users are liable to make mistakes in writing such specifications. This thesis proposes a new approach to program verification that allows users to provide only partial specification to methods. Our approach will then refine the given annotation into a more complete specification by discovering missing constraints. The discovered constraints may involve both numerical and multiset properties that could be later confirmed or revised by users. Meanwhile, we further augment our approach by requiring only partial specification to be given for primary methods of a program. Specifications for loops and auxiliary methods can then be systematically discovered by our augmented mechanism, with the help of information propagated from the primary methods. This work is aimed at verifying beyond shape properties, with the eventual goal of analysing both memory safety and functional properties for pointer-based data structures. Initial experiments have confirmed that we can automatically refine partial specifications with non-trivial constraints, thus making it easier for users to handle specifications with richer properties. For the second scenario, many programs contain invocations to unknown components and hence only part of the program code is available to the verifier. As previous works generally require the whole of program code be present, we target at the verification of memory safety and functional correctness of programs manipulating pointer-based data structures, where the program code is only partially available due to invocations to unknown components. Provided with a Hoare-style specification ({Pre} prog {Post}) where program (prog) contains calls to some unknown procedure (unknown), we infer a specification (mspecu) for the unknown part (unknown) from the calling contexts, such that the problem of verifying program (prog) can be safely reduced to the problem of proving that the unknown procedure (unknown) (once its code is available) meets the derived specification (mspecu). The expected specification (mspecu) is automatically calculated using an abduction-based shape analysis specifically designed for a combined abstract domain. We have implemented a system to validate the viability of our approach, with encouraging experimental results.
APA, Harvard, Vancouver, ISO, and other styles
5

Sălcianu, Alexandru D. (Alexandru Doru) 1975. "Pointer analysis and its applications for Java programs." Thesis, Massachusetts Institute of Technology, 2001. http://hdl.handle.net/1721.1/86781.

Full text
Abstract:
Thesis (S.M.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2001.
Includes bibliographical references (p. 135-137).
by Alexandru D. Sălcianu.
S.M.
APA, Harvard, Vancouver, ISO, and other styles
6

Wang, Jian. "Pointer analysis in Java programs using execution path information /." View abstract or full-text, 2008. http://library.ust.hk/cgi/db/thesis.pl?CSED%202008%20WANG.

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

Sălcianu, Alexandru D. (Alexandru Doru) 1975. "Pointer analysis for Java programs : novel techniques and applications." Thesis, Massachusetts Institute of Technology, 2006. http://hdl.handle.net/1721.1/38311.

Full text
Abstract:
Thesis (Ph. D.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2006.
Includes bibliographical references (p. 193-200).
This dissertation presents a pointer analysis for Java programs, together with several practical analysis applications. For each program point, the analysis is able to construct a points-to graph that describes how local variables and object fields point to objects. Each points-to graph also contains escape information that identifies the objects that are reachable from outside the analysis scope. Our pointer analysis can extract correct information by analyzing only parts of a whole program. First, our analysis analyzes a method without requiring information about its calling context. Instead, our analysis computes parameterized results that are later instantiated for each relevant call site. Second, our analysis correctly handles calls to unanalyzable methods (e.g., native methods). Hence, our analysis can trade precision for speed without sacrificing correctness: if the analysis of a call to a specific callee requires too much time, the analysis can treat that callee as unanalyzable. The results of our analysis enable standard program optimizations like the stack allocation of local objects. More interestingly, this dissertation explains how to extend the analysis to detect pure methods.
(cont.) Our analysis supports a flexible definition of method purity: a method is pure if it does not mutate any object that exists in the program state before the start of the method. Therefore, our analysis allows pure methods to allocate and mutate temporary objects (e.g., iterators) and/or construct complex object structures and return them as a result.
by Alexandru D. Sălcianu.
Ph.D.
APA, Harvard, Vancouver, ISO, and other styles
8

Rieger, Stefan Verfasser], and Joost-Pieter [Akademischer Betreuer] [Katoen. "Verification of pointer programs / Stefan Rieger ; Betreuer: Joost-Pieter Katoen." Aachen : Universitätsbibliothek der RWTH Aachen, 2009. http://d-nb.info/1128316080/34.

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

Rieger, Stefan [Verfasser], and Joost-Pieter [Akademischer Betreuer] Katoen. "Verification of pointer programs / Stefan Rieger ; Betreuer: Joost-Pieter Katoen." Aachen : Universitätsbibliothek der RWTH Aachen, 2009. http://d-nb.info/1128316080/34.

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

Simacek, Jiri. "Vérification de programmes avec structures de données complexes." Phd thesis, Université de Grenoble, 2012. http://tel.archives-ouvertes.fr/tel-00805794.

Full text
Abstract:
Les travaux décrits dans cette thèse portent sur le problème de vérification des systèmes avec espaces d'états infinis, et, en particulier, avec des structures de données chaînées. Plusieurs approches ont émergé, sans donner des solutions convenables et robustes, qui pourrait faire face aux situations rencontrées dans la pratique. Nos travaux proposent une approche nouvelle, qui combine les avantages de deux approches très prometteuses: la représentation symbolique a base d'automates d'arbre, et la logique de séparation. On présente également plusieurs améliorations concernant l'implementation de différentes opérations sur les automates d'arbre, requises pour le succès pratique de notre méthode. En particulier, on propose un algorithme optimise pour le calcul des simulations sur les systèmes de transitions étiquettes, qui se traduit dans un algorithme efficace pour le calcul des simulations sur les automates d'arbre. En outre, on présente un nouvel algorithme pour le problème d'inclusion sur les automates d'arbre. Un nombre important d'expérimentes montre que cet algorithme est plus efficace que certaines des méthodes existantes.
APA, Harvard, Vancouver, ISO, and other styles
More sources

Books on the topic "Programs with pointers"

1

Traister, Robert J. Mastering C pointers. 2nd ed. Bangalore: Prism Books, 1994.

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

Conquering C++ pointers. Boston: Academic Press Professional, 1994.

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

Pointers on C. Reading, Mass: Addison-Wesley Longman, 1998.

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

Richard, Petersen. Introductory C: Pointers, functions and files. London: Academic Press, 1992.

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

Petersen, Richard. Introductory C: Pointers, function, and files. 2nd ed. San Diego, CA: Academic Press, 1997.

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

Introductory C: Pointers, functions, and files. Boston: Academic Press, 1992.

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

Introductory C: Pointers, functions, and files. 2nd ed. San Diego: Academic, 1997.

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

C pointers and dynamic memory management. Boston: QED Pub. Group, 1993.

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

Daconta, Michael C. C++ pointers and dynamic memory management. New York: Wiley, 1995.

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

Mastering C pointers: Tools for programming power. 2nd ed. Boston: AP Professional, 1993.

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

Book chapters on the topic "Programs with pointers"

1

Matsushita, Yusuke, Takeshi Tsukada, and Naoki Kobayashi. "RustHorn: CHC-Based Verification for Rust Programs." In Programming Languages and Systems, 484–514. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-44914-8_18.

Full text
Abstract:
AbstractReduction to the satisfiablility problem for constrained Horn clauses (CHCs) is a widely studied approach to automated program verification. The current CHC-based methods for pointer-manipulating programs, however, are not very scalable. This paper proposes a novel translation of pointer-manipulating Rust programs into CHCs, which clears away pointers and heaps by leveraging ownership. We formalize the translation for a simplified core of Rust and prove its correctness. We have implemented a prototype verifier for a subset of Rust and confirmed the effectiveness of our method.
APA, Harvard, Vancouver, ISO, and other styles
2

Jaloyan, Georges-Axel, Claire Dross, Maroua Maalej, Yannick Moy, and Andrei Paskevich. "Verification of Programs with Pointers in SPARK." In Formal Methods and Software Engineering, 55–72. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-63406-3_4.

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

Vanoverberghe, Dries, Nikolai Tillmann, and Frank Piessens. "Test Input Generation for Programs with Pointers." In Tools and Algorithms for the Construction and Analysis of Systems, 277–91. Berlin, Heidelberg: Springer Berlin Heidelberg, 2009. http://dx.doi.org/10.1007/978-3-642-00768-2_25.

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

de Boer, Frank, Marcello Bonsangue, and Jurriaan Rot. "Automated Verification of Recursive Programs with Pointers." In Automated Reasoning, 149–63. Berlin, Heidelberg: Springer Berlin Heidelberg, 2012. http://dx.doi.org/10.1007/978-3-642-31365-3_14.

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

Assaf, Mounir, Julien Signoles, Frédéric Tronel, and Éric Totel. "Program Transformation for Non-interference Verification on Programs with Pointers." In Security and Privacy Protection in Information Processing Systems, 231–44. Berlin, Heidelberg: Springer Berlin Heidelberg, 2013. http://dx.doi.org/10.1007/978-3-642-39218-4_18.

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

Costea, Andreea, Amy Zhu, Nadia Polikarpova, and Ilya Sergey. "Concise Read-Only Specifications for Better Synthesis of Programs with Pointers." In Programming Languages and Systems, 141–68. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-44914-8_6.

Full text
Abstract:
AbstractIn program synthesis there is a well-known trade-off between concise and strong specifications: if a specification is too verbose, it might be harder to write than the program; if it is too weak, the synthesised program might not match the user’s intent. In this work we explore the use of annotations for restricting memory access permissions in program synthesis, and show that they can make specifications much stronger while remaining surprisingly concise. Specifically, we enhance Synthetic Separation Logic (SSL), a framework for synthesis of heap-manipulating programs, with the logical mechanism of read-only borrows.We observe that this minimalistic and conservative SSL extension benefits the synthesis in several ways, making it more (a) expressive (stronger correctness guarantees are achieved with a modest annotation overhead), (b) effective (it produces more concise and easier-to-read programs), (c) efficient (faster synthesis), and (d) robust (synthesis efficiency is less affected by the choice of the search heuristic). We explain the intuition and provide formal treatment for read-only borrows. We substantiate the claims (a)–(d) by describing our quantitative evaluation of the borrowing-aware synthesis implementation on a series of standard benchmark specifications for various heap-manipulating programs.
APA, Harvard, Vancouver, ISO, and other styles
7

Itzhaky, Shachar, Hila Peleg, Nadia Polikarpova, Reuben N. S. Rowe, and Ilya Sergey. "Deductive Synthesis of Programs with Pointers: Techniques, Challenges, Opportunities." In Computer Aided Verification, 110–34. Cham: Springer International Publishing, 2021. http://dx.doi.org/10.1007/978-3-030-81685-8_5.

Full text
Abstract:
Abstract This paper presents the main ideas behind deductive synthesis of heap-manipulating program and outlines present challenges faced by this approach as well as future opportunities for its applications.
APA, Harvard, Vancouver, ISO, and other styles
8

Asăvoae, Irina Măriuca, Frank de Boer, Marcello M. Bonsangue, Dorel Lucanu, and Jurriaan Rot. "Bounded Model Checking of Recursive Programs with Pointers in K." In Recent Trends in Algebraic Development Techniques, 59–76. Berlin, Heidelberg: Springer Berlin Heidelberg, 2013. http://dx.doi.org/10.1007/978-3-642-37635-1_4.

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

Rocha, Herbert, Rafael Menezes, Lucas C. Cordeiro, and Raimundo Barreto. "Map2Check: Using Symbolic Execution and Fuzzing." In Tools and Algorithms for the Construction and Analysis of Systems, 403–7. Cham: Springer International Publishing, 2020. http://dx.doi.org/10.1007/978-3-030-45237-7_29.

Full text
Abstract:
Abstract Map2Check is a software verification tool that combines fuzzing, symbolic execution, and inductive invariants. It automatically checks safety properties in C programs by adopting source code instrumentation to monitor data (e.g., memory pointers) from the program’s executions using LLVM compiler infrastructure. For SV-COMP 2020, we extended Map2Check to exploit an iterative deepening approach using LibFuzzer and Klee to check for safety properties. We also use Crab-LLVM to infer program invariants based on reachability analysis. Experimental results show that Map2Check can handle a wide variety of safety properties in several intricate verification tasks from SV-COMP 2020.
APA, Harvard, Vancouver, ISO, and other styles
10

Amme, W., and E. Zehendner. "Experiences in analyzing data dependences for programs with pointers and structures." In Euro-Par'97 Parallel Processing, 342–46. Berlin, Heidelberg: Springer Berlin Heidelberg, 1997. http://dx.doi.org/10.1007/bfb0002754.

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

Conference papers on the topic "Programs with pointers"

1

McGuire, Morgan. "GUIs for real-time programs using universal pointers." In ACM SIGGRAPH 2008 posters. New York, New York, USA: ACM Press, 2008. http://dx.doi.org/10.1145/1400885.1400973.

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

Wang, Dexter, and Michael Anapol. "Ultra-lightweight telescopes and precision pointers as enabling technologies for small, low cost missions." In Space Programs and Technologies Conference. Reston, Virigina: American Institute of Aeronautics and Astronautics, 1995. http://dx.doi.org/10.2514/6.1995-3602.

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

El-Korashy, Akram, Stelios Tsampas, Marco Patrignani, Dominique Devriese, Deepak Garg, and Frank Piessens. "CapablePtrs: Securely Compiling Partial Programs Using the Pointers-as-Capabilities Principle." In 2021 IEEE 34th Computer Security Foundations Symposium (CSF). IEEE, 2021. http://dx.doi.org/10.1109/csf51468.2021.00036.

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

Wang, Wei, Zhong Shao, Xinyu Jiang, and Yu Guo. "A Simple Model for Certifying Assembly Programs with First-Class Function Pointers." In 2011 IEEE 5th International Symposium on Theoretical Aspects of Software Engineering (TASE). IEEE, 2011. http://dx.doi.org/10.1109/tase.2011.16.

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

Livshits, V. Benjamin, and Monica S. Lam. "Tracking pointers with path and context sensitivity for bug detection in C programs." In the 9th European software engineering conference held jointly with 10th ACM SIGSOFT international symposium. New York, New York, USA: ACM Press, 2003. http://dx.doi.org/10.1145/940071.940114.

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

Hofmann, Martin, and Ulrich Schopp. "Pointer Programs and Undirected Reachability." In 2009 24th Annual IEEE Symposium on Logic In Computer Science (LICS). IEEE, 2009. http://dx.doi.org/10.1109/lics.2009.41.

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

Rugina, Radu, and Martin Rinard. "Pointer analysis for multithreaded programs." In the ACM SIGPLAN 1999 conference. New York, New York, USA: ACM Press, 1999. http://dx.doi.org/10.1145/301618.301645.

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

Nanda, Mangala Gowri, and S. Ramesh. "Pointer analysis of multithreaded Java programs." In the 2003 ACM symposium. New York, New York, USA: ACM Press, 2003. http://dx.doi.org/10.1145/952532.952741.

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

Zhang, Sean, Barbara G. Ryder, and William Landi. "Program decomposition for pointer aliasing." In the 4th ACM SIGSOFT symposium. New York, New York, USA: ACM Press, 1996. http://dx.doi.org/10.1145/239098.239112.

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

Farzan, Azadeh, P. Madhusudan, Niloofar Razavi, and Francesco Sorrentino. "Predicting null-pointer dereferences in concurrent programs." In the ACM SIGSOFT 20th International Symposium. New York, New York, USA: ACM Press, 2012. http://dx.doi.org/10.1145/2393596.2393651.

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

Reports on the topic "Programs with pointers"

1

Binkley, David W., and James R. Lyle. Application of the pointer state subgraph to static program slicing. Gaithersburg, MD: National Institute of Standards and Technology, 1996. http://dx.doi.org/10.6028/nist.ir.5799.

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

Duke, D., K. Magrini, V. McLane, and K. Wieda. Review of laboratory programs for women Points-of-Contact Committee. Office of Scientific and Technical Information (OSTI), June 1995. http://dx.doi.org/10.2172/106412.

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

Reyes, Angela, Benjamin Roseth, and Diego A. Vera-Cossio. Technology, Identification, and Access to Social Programs: Experimental Evidence from Panama. Inter-American Development Bank, August 2021. http://dx.doi.org/10.18235/0003485.

Full text
Abstract:
Access to identification cards (IDs) is often required to claim government benefits. However, it is unclear which policies to increase ID ownership are more effective. We experimentally analyze the effect of two policy interventions to induce the timely renewal of identification cards on access to a government social program in Panama. Sending reminders about expiration dates increased the probability of on-time renewals and of accessing benefits from a social program by 12 and 4.3 percentage points, respectively, relative to a control group. In contrast, allowing individuals to renew their ID online only increased renewals and access to benefits by 8 and 2.9 percentage points, respectively. This result was driven by lower-income individuals. The results suggest that policies to increase ownership of valid identity documentation can reduce inclusion errors in government programs and that simply granting access to digital tools may not be enough to unlock important effects.
APA, Harvard, Vancouver, ISO, and other styles
4

Byers, Loren W. Second Line of Defense Program Secondary Screening Field Data Collection--Talking Points. Office of Scientific and Technical Information (OSTI), April 2013. http://dx.doi.org/10.2172/1073744.

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

Mangasarian, O. L. Computable Numerical Bounds for Lagrange Multipliers of Stationary Points of Nonconvex Differentiable Nonlinear Programs. Fort Belvoir, VA: Defense Technical Information Center, January 1985. http://dx.doi.org/10.21236/ada153513.

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

Araujo, María Caridad, Marta Rubio-Codina, and Norbert Schady. 70 to 700 to 70,000: Lessons from the Jamaica Experiment. Inter-American Development Bank, April 2021. http://dx.doi.org/10.18235/0003210.

Full text
Abstract:
This document compares three versions of the same home visiting model, the well-known Jamaica model, which was gradually scaled-up from an efficacy trial (proof of concept) in Jamaica, to a pilot in Colombia, to an at-scale program in Peru. It first describes the design, implementation and impacts of these three programs. Then, it analyzes the threats to scalability in each of these experiences and discusses how they could have affected program outcomes, with a focus on three of the elements of the economic model of scaling in Al-Ubaydli, et al. (Forthcoming): appropriate statistical inference, properties of the population, and properties of the situation. The document reflects on the lessons learned to mitigate the threats to scalability and on how research and evaluation can be better aligned to facilitate and support the scaling-up process of early child development interventions. It points out those attributes that interventions must maintain to ensure effectiveness at scale. Similarly, political support is also identified as indispensable.
APA, Harvard, Vancouver, ISO, and other styles
7

McLane, V., and A. Layne. Department of Energy Review of Laboratory Programs for Women Points-of-Contact Committee: Comparative Report, June 1995. Office of Scientific and Technical Information (OSTI), June 1995. http://dx.doi.org/10.2172/1089592.

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

Reyes, Angela, Benjamin Roseth, and Diego A. Vera-Cossio. Research Insights: How Digital Tools Increase Access to Government Services and Social Programs through On-time Renewals of IDs. Inter-American Development Bank, August 2021. http://dx.doi.org/10.18235/0003572.

Full text
Abstract:
Sending SMS reminders increased the probability of on-time renewals of IDs by 12 percentage points, while also allowing citizens to renew their IDs online only increased renewals by 8 percentage points. Providing an online option (instead of in-person renewals) was less effective due to a poor user experience with the online procedure. The poorest individuals who received reminders were also more likely to receive transfers from an emergency in-kind transfer delivered through digital vouchers.
APA, Harvard, Vancouver, ISO, and other styles
9

Geyer, Anton. Assessment des FFG-Programms „F&E-Infrastrukturförderung“. Inspire research Beratungsgesellschaft m.b.H., March 2020. http://dx.doi.org/10.22163/fteval.2020.497.

Full text
Abstract:
The FFG conducted two calls for the "R&D Infrastructure Funding" programme in 2016 and 2018. The programme was developed to take into account the central role of R&D infrastructure in generating new knowledge and technologies. The assessment of the FFG programme "R&D Infrastructure Funding" is intended to review the central points of the programme format and to support the FFG in making improvements and tightening up the programme design. The assessment focuses on the question of the extent to which the programme in its current form and implementation succeeds in achieving the intended goals. Both the tender modalities and the formal funding conditions and evaluation criteria for the applications will be reviewed.
APA, Harvard, Vancouver, ISO, and other styles
10

Dubeck, Margaret M., Jonathan M. B. Stern, and Rehemah Nabacwa. Learning to Read in a Local Language in Uganda: Creating Learner Profiles to Track Progress and Guide Instruction Using Early Grade Reading Assessment Results. RTI Press, June 2021. http://dx.doi.org/10.3768/rtipress.2021.op.0068.2106.

Full text
Abstract:
The Early Grade Reading Assessment (EGRA) is used to evaluate studies and monitor projects that address reading skills in low- and middle-income countries. Results are often described solely in terms of a passage-reading subtask, thereby overlooking progress in related skills. Using archival data of cohort samples from Uganda at two time points in three languages (Ganda, Lango, and Runyankore-Rukiga), we explored a methodology that uses passage-reading results to create five learner profiles: Nonreader, Beginner, Instructional, Fluent, and Next-Level Ready. We compared learner profiles with results on other subtasks to identify the skills students would need to develop to progress from one profile to another. We then used regression models to determine whether students’ learner profiles were related to their results on the various subtasks. We found membership in four categories. We also found a shift in the distribution of learner profiles from Grade 1 to Grade 4, which is useful for establishing program effectiveness. The distribution of profiles within grades expanded as students progressed through the early elementary grades. We recommend that those who are discussing EGRA results describe students by profiles and by the numbers that shift from one profile to another over time. Doing so would help describe abilities and instructional needs and would show changes in a meaningful way.
APA, Harvard, Vancouver, ISO, and other styles
You might also be interested in the extended bibliographies on the topic 'Programs with pointers' for particular source types:
Journal articles Dissertations / Theses Books
We offer discounts on all premium plans for authors whose works are included in thematic literature selections. Contact us to get a unique promo code!

To the bibliography