Dissertations / Theses on the topic 'Debugging'
To see the other types of publications on this topic, follow the link: Debugging.
Create a spot-on reference in APA, MLA, Chicago, Harvard, and other styles
Consult the top 50 dissertations / theses for your research on the topic 'Debugging.'
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.
Browse dissertations / theses on a wide variety of disciplines and organise your bibliography correctly.
1
Scerpa, Daniel. "Debugging Reversibile." Bachelor's thesis, Alma Mater Studiorum - Università di Bologna, 2018. http://amslaurea.unibo.it/15470/.
Full textAbstract:
Per migliorare l'efficienza del processo di debug, nel corso degli anni, è cresciuta sempre di più l’idea di mettere, a disposizione del programmatore, un debugger che consentisse non solo, di fare un passo avanti nel codice, ma anche la possibilità di ripercorrerre all’indietro l’esecuzione del programma per ridurre i costi e i tempi nel sviluppare software.
2
Murphy, Toriano A. "Statistical debugging." Thesis, Monterey, Calif. : Naval Postgraduate School, 2008. http://bosun.nps.edu/uhtbin/hyperion-image.exe/08Mar%5FMurphy_Toriano.pdf.
Full textAbstract:
Thesis (M.S. in Computer Science)--Naval Postgraduate School, March 2008.Thesis Advisor(s): Auguston, Mikhail. "March 2008." Description based on title screen as viewed on May 5, 2008. Includes bibliographical references (p. 91). Also available in print.
3
Petrillo, Fábio dos Santos. "Swarm debugging : the collective debugging intelligence of the crowd." reponame:Biblioteca Digital de Teses e Dissertações da UFRGS, 2016. http://hdl.handle.net/10183/150176.
Full textAbstract:
As formigas são criaturas fascinantes que, além dos avanços na biologia também inspiraram pesquisas sobre teoria da informação. Em particular, o estudo resultou na criação da Teoria da Forragem de Informação, que descreve como os agentes de buscam informações em seu ambiente. Esta teoria também explica fenômenos recentes e bem-sucedidos, como crowd sourcing. Crowdsourcing tem sido aplicado a muitas atividades em engenharia de software, incluindo desenvolvimento, tradução e testes, mas uma atividade parece resistir: depuração. No entanto, os desenvolvedores sabem que a depuração pode exigir dedicação, esforço, longas horas de trabalho, por vezes, para mudar uma linha de código único. Nós introduzimos o conceito de Depuração em Enxame, para trazer crowd sourcing para a atividade de depuração. Através de crowd sourcing, pretendemos ajudar os desenvolvedores, capitalizando a sua dedicação, esforço e longas horas de trabalho para facilitar atividades de depuração. Mostramos que a depuração enxame requer uma abordagem específica para recolher informações relevantes, e descrevemos sua infra-estrutura. Mostramos também que a depuração em enxame pode reduzir o esforço desenvolvedores. Concluímos com as vantagens e limitações atuais de depuração enxame, e sugerir caminhos para superar estas limitações e ainda mais a adoção de crowd sourcing para atividades de depuração.Ants are fascinating creatures that beyond the advances in biology have also inspired research on information theory. In particular, their study resulted in the creation of the Information Foraging Theory, which describes how agents forages for information in their environment. This theory also explains recent and fruitful phenomena, such as crowdsourcing. Many activities in software engineering have applied crowdsourcing, including development, translation, and testing, but one action seems to resist: debugging. Developers know that debugging can require dedication, effort, long hours of work, sometimes for changing one line of code only. We introduce the concept of Swarm Debugging, to bring crowdsourcing to the activity of debugging. Through crowdsourcing, we aim at helping developers by capitalizing on their dedication, effort, and long hours of work to ease debugging activities of their peers or theirs, on other bugs. We show that swarm debugging requires a particular approach to collect relevant information, and we describe the Swarm Debugging Infrastructure. We also show that swarm debugging minimizes developers effort. We conclude with the advantages and current limitations of swarm debugging and suggest directions to overcome these limitations and further the adoption of crowdsourcing for debugging activities.
4
Searle, Aaron James. "Automatic relative debugging." Thesis, Queensland University of Technology, 2006. https://eprints.qut.edu.au/16445/1/Aaron_Searle_Thesis.pdf.
Full textAbstract:
Relative Debugging is a paradigm that assists users to locate errors in programs that have been corrected or enhanced. In particular, the contents of key data structures in the development version are compared with the contents of the corresponding data structures, in an existing version, as the two programs execute. If the values of two corresponding data structures differ at points where they should not, an error may exist and the user is notified.
Relative Debugging requires users to identify the corresponding data structures within the two programs, and the locations at which the comparisons should be performed.
To quickly and effectively identify useful data structures and comparison points requires that users have a detailed knowledge of the two programs under consideration. Without a detailed knowledge of the two programs, the task of locating useful data structures and comparison points can quickly become a difficult and time consuming process. Prior to the research detailed in this thesis, the Relative Debugging paradigm did not provide any assistance that allowed users to quickly and effectively identify suitable data structures and program points that will help discover the source of an error.
Our research efforts have been directed at enhancing the Relative Debugging paradigm. The outcome of this research is the discovery of techniques that empower
Relative Debugging users to become more productive and allow the Relative Debugging paradigm to be significantly enhanced. Specifically, the research has resulted in the following three contributions:
1. A Systematic Approach to Relative Debugging.
2. Data Flow Browsing for Relative Debugging.
3. Automatic Relative Debugging.
These contributions have enhanced the Relative Debugging paradigm and allow errors to be localized with little human interaction. Minimizing the user's involvement reduces the cost of debugging programs that have been corrected or enhanced, and has a significant impact on current debugging practices.
5
Searle, Aaron James. "Automatic relative debugging." Queensland University of Technology, 2006. http://eprints.qut.edu.au/16445/.
Full textAbstract:
Relative Debugging is a paradigm that assists users to locate errors in programs that have been corrected or enhanced. In particular, the contents of key data structures in the development version are compared with the contents of the corresponding data structures, in an existing version, as the two programs execute. If the values of two corresponding data structures differ at points where they should not, an error may exist and the user is notified. Relative Debugging requires users to identify the corresponding data structures within the two programs, and the locations at which the comparisons should be performed. To quickly and effectively identify useful data structures and comparison points requires that users have a detailed knowledge of the two programs under consideration. Without a detailed knowledge of the two programs, the task of locating useful data structures and comparison points can quickly become a difficult and time consuming process. Prior to the research detailed in this thesis, the Relative Debugging paradigm did not provide any assistance that allowed users to quickly and effectively identify suitable data structures and program points that will help discover the source of an error. Our research efforts have been directed at enhancing the Relative Debugging paradigm. The outcome of this research is the discovery of techniques that empower Relative Debugging users to become more productive and allow the Relative Debugging paradigm to be significantly enhanced. Specifically, the research has resulted in the following three contributions: 1. A Systematic Approach to Relative Debugging. 2. Data Flow Browsing for Relative Debugging. 3. Automatic Relative Debugging. These contributions have enhanced the Relative Debugging paradigm and allow errors to be localized with little human interaction. Minimizing the user's involvement reduces the cost of debugging programs that have been corrected or enhanced, and has a significant impact on current debugging practices.
6
Müller, Thomas. "OpenAFS Fileserver Debugging/Tuning." Universitätsbibliothek Chemnitz, 2003. http://nbn-resolving.de/urn:nbn:de:swb:ch1-200301305.
Full textAbstract:
Unterlagen zu einem Tutorium im Rahmen des AFS-Workshops 2003 am DESY Zeuthen.
Die Suche von Fehlern in komplexen Systemen setzt immer voraus, dass der korrekte Zustand des Systems bekannt ist. Denn nur auf diese Art und Weise kann man erkennen, dass es sich in einer konkreten Situation um ein Fehlverhalten handelt.
In diesem Tutorium werden daher Normal- oder Sollzustände von OpenAFS-Fileservern beschrieben. Es werden einzelne Datenstrukturen dargestellt und am Beispiel der Callback-Verwaltung des Fileservers wird gezeigt, wie diese Datenstrukturen zur Laufzeit des Servers organisiert werden.
7
Pothier, Guillaume. "Towards Practical Omniscient Debugging." Tesis, Universidad de Chile, 2011. http://www.repositorio.uchile.cl/handle/2250/102687.
Full text
8
Binks, Dominic Frank Julian. "Declarative debugging in Gödel." Thesis, University of Bristol, 1995. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.296587.
Full text
9
Mutti, Danilo. "Coverage based debugging visualization." Universidade de São Paulo, 2014. http://www.teses.usp.br/teses/disponiveis/100/100131/tde-15122014-230109/.
Full textAbstract:
Fault localization is a costly task in the debugging process. Usually, developers analyze failing test cases to search for faults in the programs code. Visualization techniques have been proposed to help developers grasp the source code and focus their attention onto locations more likely to contain bugs. In general, these techniques utilize two-dimensional visualization approaches. We introduce a three-dimentional visual metaphor, called CodeForest, which represents a software as a cacti forest. In the CodeForest, nodes (sets of statements executed in sequence) are thorns, methods are branches, and classes are cacti. Heuristicsbased on the frequency that lines of codes are executed in successful and failing test cases are used to assign suspiciousness values to the elements (thorns, branches, and cacti) of the forest. The new metaphor was implemented as a plug-in targeted to the Eclipse Platform. This plug-in includes the mapping of suspiciousness values to elements of a virtual forest, a parameterized trimmer, which filters elements based on their score or text, and a list of most suspicious methods (also known as \"roadmap\"), to guide the developer on his/her debugging session. An exploratory experiment was conducted; the results indicates that the tool supports developers with and without experience. Users with low or no experience utilized the roadmap and the virtual 3D environment to investigate the defect. More experienced users prefer to use the roadmap as a guide to narrow which parts of the source code should be explored.Localizar falhas é uma tarefa custosa do processo de depuração. Normalmente, os desenvolvedores analisam casos de teste que falham para procurar por defeitos no código fonte de um programa. Técnicas de visualização têm sido propostas para ajudar os desenvolvedores a entender o código fonte e focar sua atenção nos locais com a maior probabilidade de conterem defeitos. Geralmente, essas técnicas utilizam abordagens de visualização bidimensional. Nesse trabalho é introduzida uma metáfora visual em três dimensões, chamada CodeForest, que representa um programa como uma floresta de cactus. Na CodeForest, nós (conjunto de comandos executados em sequência) são representados como espinhos, métodos como galhos e classes como troncos. Para associar valores de suspeição aos elementos da floresta (espinhos, galhos e troncos) utilizam-se heurísticas, baseadas na frequência com que linhas de código são executadas em casos de teste finalizados com sucesso e com falha. A nova metáfora foi implementada como um complemento da plataforma Eclipse de desenvolvimento de programas. Esse complemento inclui o mapeamento dos valores de suspeição para elementos de uma floresta, uma ferramenta de poda parametrizada - que filtra elementos com base em seu texto e valor de suspeição - e uma lista dos métodos mais suspeitos (conhecida como roteiro) para guiar o desenvolvedor em sua sessão de depuração. Um experimento exploratório foi conduzido e os resultados indicam que a ferramenta apoia a tarefa de depuração tanto de desenvolvedores experientes quanto inexperientes. Usuários com pouca ou nenhuma experiência utilizaram o roteiro e o ambiente virtual 3D para investigar o defeito. Usuários mais experientes preferiram utilizar o roteiro como um guia para restringir quais partes do código fonte deveriam ser exploradas.
10
Yamane, Yoshito. "Event query based debugging /." Thesis, Connect to this title online; UW restricted, 1997. http://hdl.handle.net/1773/6958.
Full text
11
Müller, Thomas. "OpenAFS: Debugging-Methoden und -Tools." Universitätsbibliothek Chemnitz, 2002. http://nbn-resolving.de/urn:nbn:de:bsz:ch1-200201181.
Full textAbstract:
Unterlagen zu einem Vortrag im Rahmen des AFS-Workshops 2002 an der ETH Zürich.
Gegenstand der Vortrags sind Tools zum Debugging und zur Analyse des Verhaltens von AFS-Servern und -Clients. Die meisten dieser Tools sind im Source-Baum von OpenAFS enthalten, jedoch kaum dokumentiert.
12
Thun, Julia, and Rebin Kadouri. "Automating debugging through data mining." Thesis, KTH, Data- och elektroteknik, 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-203244.
Full textAbstract:
Contemporary technological systems generate massive quantities of log messages. These messages can be stored, searched and visualized efficiently using log management and analysis tools. The analysis of log messages offer insights into system behavior such as performance, server status and execution faults in web applications. iStone AB wants to explore the possibility to automate their debugging process. Since iStone does most parts of their debugging manually, it takes time to find errors within the system. The aim was therefore to find different solutions to reduce the time it takes to debug. An analysis of log messages within access – and console logs were made, so that the most appropriate data mining techniques for iStone’s system would be chosen. Data mining algorithms and log management and analysis tools were compared. The result of the comparisons showed that the ELK Stack as well as a mixture between Eclat and a hybrid algorithm (Eclat and Apriori) were the most appropriate choices. To demonstrate their feasibility, the ELK Stack and Eclat were implemented. The produced results show that data mining and the use of a platform for log analysis can facilitate and reduce the time it takes to debug.Dagens system genererar stora mängder av loggmeddelanden. Dessa meddelanden kan effektivt lagras, sökas och visualiseras genom att använda sig av logghanteringsverktyg. Analys av loggmeddelanden ger insikt i systemets beteende såsom prestanda, serverstatus och exekveringsfel som kan uppkomma i webbapplikationer. iStone AB vill undersöka möjligheten att automatisera felsökning. Eftersom iStone till mestadels utför deras felsökning manuellt så tar det tid att hitta fel inom systemet. Syftet var att därför att finna olika lösningar som reducerar tiden det tar att felsöka. En analys av loggmeddelanden inom access – och konsolloggar utfördes för att välja de mest lämpade data mining tekniker för iStone’s system. Data mining algoritmer och logghanteringsverktyg jämfördes. Resultatet av jämförelserna visade att ELK Stacken samt en blandning av Eclat och en hybrid algoritm (Eclat och Apriori) var de lämpligaste valen. För att visa att så är fallet så implementerades ELK Stacken och Eclat. De framställda resultaten visar att data mining och användning av en plattform för logganalys kan underlätta och minska den tid det tar för att felsöka.
13
Al, Samisti Fanti Machmount. "Visual Debugging of Dataflow Systems." Thesis, KTH, Skolan för informations- och kommunikationsteknik (ICT), 2017. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-222376.
Full textAbstract:
Big data processing has seen vast integration into the idea of data analysis in live streaming and batch environments. A plethora of tools have been developed to break down a problem into manageable tasks and to allocate both software and hardware resources in a distributed and fault tolerant manner. Apache Spark is one of the most well known platforms for large-scale cluster computation. In SICS Swedish ICT, Spark runs on top of an in-house developed solution. HopsWorks provides a graphical user interface to the Hops platform that aims to simplify the process of configuring a Hadoop environment and improving upon it. The user interface includes, among other capabilities, an array of tools for executing distributed applications such as Spark, TensorFlow, Flink with a variety of input and output sources, e.g. Kafka, HDFS files etc. Currently the available tools to monitor and instrument a stack that includes the aforementioned technologies come from both the corporate and open source world. The former is usually part of a bigger family of products running on proprietary code. In contrast, the latter offers a wider variety of choices with the most prominent ones lacking either the flexibility in exchange for a more generic approach or the ease of gaining meaningful insight except of the most experienced users. The contribution of this project is a visualization tool in the form of a web user interface, part of the Hops platform, for understanding, debugging and ultimately optimizing the resource allocation and performance of dataflow applications. These processes are based both on the abstraction provided by the dataflow programming paradigm and on systems concepts such as properties of data, how much variability in the data, computation, distribution, and other system wide resources.Behandling av stora datamängder har på senare tid blivit en viktig del av data analys i strömning och batch-processering. En uppsjö av verktyg har blivit framtagna för att bryta ner problem till mindre uppgifter och för att använda såväl hårdvara som mjukvara på ett distribuerat och fel tolerant sätt. Apache Spark är en av de mest kända plattformarna för beräkningar på storskaliga kluster. På SICS Swedish ICT, används Spark på deras egna lösning. HopsWorks tillhandahåller ett grafiskt gränssnitt för Hops plattformen med målet att förenkla processen att konfiguera Hadoop miljön och förbättra den. Användargränssnittet inkluderar, utöver annan funktionalitet, ett flertal verktyg för att exekvera distribuerade applikationer såsom Spark, TensorFlow, Flink med ett antal olika datakällor såsom Kafka och HDFS. De verktyg som finns för att övervaka den tidigarenämnda teknologi-stacken kommer från både företag och öppna källkod projekt. Den tidigare är vanligtvis en del av en större familj med produkter som kör på proprietär kod. I kontrast mot den senare, som erbjuder en större mängd med val där de viktigaste har bristande flexibilitet i utbyte mot ett mer generiskt tillvägagångssätt eller enkelhet att få nyttig information förutom för de mest erfarna användarna. Bidraget från det här projektet är ett visualiseringsspråk i form av ett webbanvändargränssnitt, integrerat med Hops plattformen, för förståelse, felsökning och i slutändan kunna optimera resursallokering och prestanda för dataflödesapplikationer. Dessa processer är baserade på både abstraktionen från dataflöde programmerings paradigmen och på systemkoncept såsom dataegenskaper, datavariabilitet, beräkning, distribution och andra systemegenskaper.
14
Gunaseelan, L. "Debugging of Distributed object systems." Diss., Georgia Institute of Technology, 1994. http://hdl.handle.net/1853/9219.
Full text
15
Balfour, J. "Source level debugging for microprocessors." Thesis, Lancaster University, 1986. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.379582.
Full text
16
Penney, Alastair William. "Augmenting trace-based functional debugging." Thesis, University of Bristol, 2000. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.310594.
Full text
17
Cooper, Robert Charles Beaumont. "Debugging concurrent and distributed programs." Thesis, University of Cambridge, 1987. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.256762.
Full text
18
Michaeli, Tilman [Verfasser]. "Debugging im Informatikunterricht / Tilman Michaeli." Berlin : Freie Universität Berlin, 2021. http://d-nb.info/1225349508/34.
Full text
19
Tammana, Praveen Aravind Babu. "Software-defined datacenter network debugging." Thesis, University of Edinburgh, 2018. http://hdl.handle.net/1842/31326.
Full textAbstract:
Software-defined Networking (SDN) enables flexible network management, but as networks evolve to a large number of end-points with diverse network policies, higher speed, and higher utilization, abstraction of networks by SDN makes monitoring and debugging network problems increasingly harder and challenging. While some problems impact packet processing in the data plane (e.g., congestion), some cause policy deployment failures (e.g., hardware bugs); both create inconsistency between operator intent and actual network behavior. Existing debugging tools are not sufficient to accurately detect, localize, and understand the root cause of problems observed in a large-scale networks; either they lack in-network resources (compute, memory, or/and network bandwidth) or take long time for debugging network problems. This thesis presents three debugging tools: PathDump, SwitchPointer, and Scout, and a technique for tracing packet trajectories called CherryPick. We call for a different approach to network monitoring and debugging: in contrast to implementing debugging functionality entirely in-network, we should carefully partition the debugging tasks between end-hosts and network elements. Towards this direction, we present CherryPick, PathDump, and SwitchPointer. The core of CherryPick is to cherry-pick the links that are key to representing an end-to-end path of a packet, and to embed picked linkIDs into its header on its way to destination. PathDump is an end-host based network debugger based on tracing packet trajectories, and exploits resources at the end-hosts to implement various monitoring and debugging functionalities. PathDump currently runs over a real network comprising only of commodity hardware, and yet, can support surprisingly a large class of network debugging problems with minimal in-network functionality. The key contributions of SwitchPointer is to efficiently provide network visibility to end-host based network debuggers like PathDump by using switch memory as a "directory service" - each switch, rather than storing telemetry data necessary for debugging functionalities, stores pointers to end hosts where relevant telemetry data is stored. The key design choice of thinking about memory as a directory service allows to solve performance problems that were hard or infeasible with existing designs. Finally, we present and solve a network policy fault localization problem that arises in operating policy management frameworks for a production network. We develop Scout, a fully-automated system that localizes faults in a large scale policy deployment and further pin-points the physical-level failures which are most likely cause for observed faults.
20
Nedelchev, A. (Aleksandar). "Automating Linux post-mortem debugging." Master's thesis, University of Oulu, 2018. http://urn.fi/URN:NBN:fi:oulu-201806022428.
Full textAbstract:
Post-mortem debugging is often the last bastion of debugging solutions. It involves analyzing a raw memory dump of either a portion of memory or the whole memory of the system at an instance of time, much like a photograph. In order to able to read such a memory dump, you have to have knowledge about how the system was built and implemented. Some systems, especially embedded ones, are the ones that can benefit the most from it, due to other solutions being impractical or simply unavailable. The process of post-mortem debugging is cumbersome, as it requires a lot of file operations in order to be executed. The automation of post-mortem debugging can potentially increase its effectiveness greatly.
This research was conducted at a large-scale Finnish telecommunications company, which uses embedded Linux devices in its products. The objective of this research was to provide a solution for automating Linux post-mortem debugging, which is better than the current solutions and workings available in the case company. The research method used is the acclaimed design-science research.
The research justifies its approach by looking at related work exploring the benefits of automated debugging in general. It also looks at common trends and pitfalls when dealing with highly complex specialized embedded processing environments. The design science artifact, created by this research, was made by combining the justification from the related work, combined with the requirements and processes of the case company environment. The evaluation of the research, both quantitative and qualitative, explores its benefits and drawbacks from multiple points of view.
Overall, the implementation of the design science artifact, created by this research, was a success. Its time-saving capabilities were clearly demonstrated, as well as its potential use as a learning tool for new hires and non-technical staff. The main drawback identified was the need of constant maintenance, which is common for applications with great variability in their environment.
21
Insa, Cabrera David. "Optimization Techniques for Algorithmic Debugging." Doctoral thesis, Universitat Politècnica de València, 2016. http://hdl.handle.net/10251/68506.
Full textAbstract:
[EN] Nowadays, undetected programming bugs produce a waste of billions of dollars per year to private and public companies and institutions. In spite of this, no significant advances in the debugging area that help developers along the software development process have been achieved yet. In fact, the same debugging techniques that were used 20 years ago are still being used now. Along the time, some alternatives have appeared, but there still is a long way for them to be useful enough to get into the software development process. One of them is algorithmic debugging, which abstracts the information the user has to investigate to debug the program, allowing them to focus on what is happening instead of how it is happening. This abstraction comes at a price: the granularity level of the bugs that can be detected allows for isolating wrongly implemented functions, but which part of them contains the bug cannot be found out yet. This thesis focusses on improving algorithmic debugging in many aspects. Concretely, the main aims of this thesis are to reduce the time the user needs to detect a programming bug as well as to provide the user with more detailed information about where the bug is located. To achieve these goals, some techniques have been developed to start the debugging sessions as soon as possible, to reduce the number of questions the user is going to be asked about, and to augment the granularity level of those bugs that algorithmic debugging can detect, allowing the debugger in this way to keep looking for bugs even inside functions. As a result of this thesis, three completely new techniques have been defined, an already existent technique has been improved, and two new algorithmic debugging search strategies have been defined that improve the already existent ones. Besides these theoretical results, a fully functional algorithmic debugger has been implemented that contains and supports all these techniques and strategies. This debugger is written in Java, and it debugs Java code. The election of this language is justified because it is currently one of the most widely extended and used languages. Also because it contains an interesting combination of unsolved challenges for algorithmic debugging. To further increase its usability, the debugger has been later adapted as an Eclipse plugin, so it could be used by a wider number of users. These two debuggers are publicly available, so any interested person can access them and continue with the research if they wish so.[ES] Hoy en día, los errores no detectados de programación suponen un gasto de miles de millones al año para las empresas e instituciones públicas y privadas. A pesar de esto, no ha habido ningún avance significativo en el área de la depuración que ayude a los desarrolladores durante la fase de desarrollo de software. De hecho, las mismas técnicas de depuración que se utilizaban hace 20 años se siguen utilizando ahora. A lo largo del tiempo, han surgido algunas alternativas, pero todavía queda un largo camino para que estas sean lo suficientemente útiles como para abrirse camino en el proceso de desarrollo de software. Una de ellas es la depuración algorítmica, la cual abstrae la información que el programador debe investigar para depurar el programa, permitiéndole de este modo centrarse en el qué está ocurriendo en vez de en el cómo. Esta abstracción tiene un coste: el nivel de granularidad de los errores que pueden detectarse nos permite como máximo aislar funciones mal implementadas, pero no averiguar qué parte de estas contiene el error. Esta tesis se centra en mejorar la depuración algorítmica en muchos aspectos. Concretamente, los principales objetivos de esta tesis son reducir el tiempo que el usuario necesita para detectar un error de programación así como proporcionar información más detallada de dónde se encuentra el error. Para conseguir estos objetivos, se han desarrollado técnicas para iniciar las sesiones de depuración lo antes posible, reducir el número de preguntas que se le van a realizar al usuario, y aumentar el nivel de granularidad de los errores que la depuración algorítmica puede detectar, permitiendo así seguir buscando el error incluso dentro de las funciones. Como resultado de esta tesis, se han definido tres técnicas completamente nuevas, se ha mejorado una técnica ya existente, y se han definido dos nuevas estrategias de depuración algorítmica que mejoran las previamente existentes. Además de los resultados teóricos, también se ha desarrollado un depurador algorítmico completamente funcional que contiene y respalda todas estas técnicas y estrategias. Este depurador está escrito en Java y depura código Java. La elección de este lenguaje se justifica debido a que es uno de los lenguajes más ampliamente extendidos y usados actualmente. También debido a que contiene una combinación interesante de retos todavía sin resolver para la depuración algorítmica. Para aumentar todavía más su usabilidad, el depurador ha sido posteriormente adaptado como un plugin de Eclipse, de tal manera que pudiese ser usado por un número más amplio de usuarios. Estos dos depuradores están públicamente disponibles para que cualquier persona interesada pueda acceder a ellos y continuar con la investigación si así lo deseara.
[CAT] Hui en dia, els errors no detectats de programació suposen una despesa de milers de milions a l'any per a les empreses i institucions públiques i privades. Tot i això, no hi ha hagut cap avanç significatiu en l'àrea de la depuració que ajude als desenvolupadors durant la fase de desenvolupament de programari. De fet, les mateixes tècniques de depuració que s'utilitzaven fa 20 anys es continuen utilitzant ara. Al llarg del temps, han sorgit algunes alternatives, però encara queda un llarg camí perquè estes siguen prou útils com per a obrir-se camí en el procés de desenvolupament de programari. Una d'elles és la depuració algorítmica, la qual abstrau la informació que el programador ha d'investigar per a depurar el programa, permetent-li d'esta manera centrar-se en el què està ocorrent en compte de en el com. Esta abstracció té un cost: el nivell de granularitat dels errors que poden detectar-se ens permet com a màxim aïllar funcions mal implementades, però no esbrinar quina part d'estes conté l'error. Esta tesi es centra a millorar la depuració algorítmica en molts aspectes. Concretament, els principals objectius d'esta tesi són reduir el temps que l'usuari necessita per a detectar un error de programació així com proporcionar informació més detallada d'on es troba l'error. Per a aconseguir estos objectius, s'han desenvolupat tècniques per a iniciar les sessions de depuració com més prompte millor, reduir el nombre de preguntes que se li formularan a l'usuari, i augmentar el nivell de granularitat dels errors que la depuració algorítmica pot detectar, permetent així continuar buscant l'error inclús dins de les funcions. Com resultat d'esta tesi, s'han definit tres tècniques completament noves, s'ha millorat una tècnica ja existent, i s'han definit dos noves estratègies de depuració algorítmica que milloren les prèviament existents. A més dels resultats teòrics, també s'ha desenvolupat un depurador algorítmic completament funcional que conté i protegix totes estes tècniques i estratègies. Este depurador està escrit en Java i depura codi Java. L'elecció d'este llenguatge es justifica pel fet que és un dels llenguatges més àmpliament estesos i usats actualment. També pel fet que conté una combinació interessant de reptes encara sense resoldre per a la depuració algorítmica. Per a augmentar encara més la seua usabilitat, el depurador ha sigut posteriorment adaptat com un plugin d'Eclipse, de tal manera que poguera ser usat per un nombre més ampli d'usuaris. Estos dos depuradors estan públicament disponibles perquè qualsevol persona interessada puga accedir a ells i continuar amb la investigació si així ho desitjara.
Insa Cabrera, D. (2016). Optimization Techniques for Algorithmic Debugging [Tesis doctoral no publicada]. Universitat Politècnica de València. https://doi.org/10.4995/Thesis/10251/68506
TESIS
Premiado
22
Dao, Darren Duc. "Live debugging of distributed systems." Diss., Connect to a 24 p. preview or request complete full text in PDF format. Access restricted to UC campuses, 2008. http://wwwlib.umi.com/cr/ucsd/fullcit?p1457315.
Full textAbstract:
Thesis (M.S.)--University of California, San Diego, 2008.Title from first page of PDF file (viewed November 6, 2008). Available via ProQuest Digital Dissertations. Includes bibliographical references (p. 43-44).
23
Chen, Yan. "A tool for auralized debugging." Online access for everyone, 2005. http://www.dissertations.wsu.edu/Thesis/Summer2005/y%5Fchen%5F063005.pdf.
Full text
24
Sewry, David Andrew. "Behavioural model debugging in Linda." Thesis, Rhodes University, 1994. http://hdl.handle.net/10962/d1006697.
Full textAbstract:
This thesis investigates event-based behavioural model debugging in Linda. A study is presented of the Linda parallel programming paradigm, its amenability to debugging, and a model for debugging Linda programs using Milner's CCS. In support of the construction of expected behaviour models, a Linda program specification language is proposed. A behaviour recognition engine that is based on such specifications is also discussed. It is shown that Linda's distinctive characteristics make it amenable to debugging without the usual problems associated with paraUel debuggers. Furthermore, it is shown that a behavioural model debugger, based on the proposed specification language, effectively exploits the debugging opportunity. The ideas developed in the thesis are demonstrated in an experimental Modula-2 Linda system.
25
Cagnin, Francesco <1991>. "LLDBagility: practical macOS kernel debugging." Master's Degree Thesis, Università Ca' Foscari Venezia, 2020. http://hdl.handle.net/10579/16240.
Full textAbstract:
The effectiveness of debugging software issues depends largely on the capabilities of the tools available to aid in such task. To debug the macOS kernel there is at present no real alternative other than the basic debugger integrated in the kernel itself, intended to be used remotely from another machine through a full-fledged debugger like LLDB. Due to design constraints and implementative choices, this approach has however several drawbacks, such as the necessity of modifying the system configuration, or the impossibility to set hardware breakpoints or to pause the execution of kernel from the debugger.
The aim of this work was improving the overall debugging experience for the macOS kernel. To this end we developed LLDBagility, a tool to enable kernel debugging via virtual machine introspection. LLDBagility connects LLDB to any unmodified macOS virtual machine running on a patched version of the VirtualBox hypervisor, allowing the debugger to fully control the machine without the system being aware of the process. This solution have made possible to overcome all limitations of the classic kernel debugging approach, and also to implement new useful features like the ability to save and eventually restore the state of the machine directly from the debugger.
26
Fabbretti, Giovanni. "Causal-Consistent Debugging of Distributed Erlang." Master's thesis, Alma Mater Studiorum - Università di Bologna, 2020. http://amslaurea.unibo.it/22195/.
Full textAbstract:
The main purpose of this work is to study the reversibility in a concurrent and distributed environment. Reversing the execution of a program in such environment is not straightforward, indeed in order to undo a step performed by one of the, potentially many, processes of the system one has to make sure that also all of its consequences, if any, have been undone beforehand. This notion is usually referred to as causal consistency. Here, we study reversibility in the context of the Erlang language. In order to reverse the execution of a concurrent and distributed erlang program we define a forward semantics which, at each step performed by the program, stores in an external device, called history, auxiliary pieces of information that later on can be used to undo the step. In addition to the forward semantics we also develop a backward semantics and a rollback semantics, the former tells how and when we can undo a step while the latter allows us to undo several steps in an automatic manner. Lastly, we present a proof-of-concept implementation of a debugger able to reverse the execution of a concurrent and distributed program written in Erlang.
27
Kalyanpur, Aditya Anand. "Debugging and repair of OWL ontologies." College Park, Md. : University of Maryland, 2006. http://hdl.handle.net/1903/3820.
Full textAbstract:
Thesis (Ph. D.) -- University of Maryland, College Park, 2006.Thesis research directed by: Computer Science. Title from t.p. of PDF. Includes bibliographical references. Published by UMI Dissertation Services, Ann Arbor, Mich. Also available in paper.
28
Axelsson, Erik. "Debugging Software for Multi-core Systems." Thesis, KTH, Skolan för informations- och kommunikationsteknik (ICT), 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-42441.
Full textAbstract:
The world of computer science has seen a big change the last years. The physical limitations in just increasing frequency when trying to increase the speed in processors has lead to a new era - multi-core. Systems based on multi-core processors brings a much higher level of flexibility to the designer, possibilities to experiment with different frequencies and voltages on on single chip. Unfortunately this flexibility also leads to a more complex system, hard to monitor and debug. The software implemented in multi-core processors needs to be parallelized and distributed very efficiently to take advantage of the architecture of the processor. The way information is exchanged between units in the processors and how the complex memory architecture, often with several levels of cache, is accessed are essential factors for the performance. It is often the case that minor changes in the software lead to big differences in performance. To be able to analyze the software when it is running on the chip it is of utmost importance to have a system that monitor the chip. One drawback with multi-core processors is that the integration of more logic into one chip decreases the external observability of the system. Hardware manufacturers have been trying to develop solutions for this problem and nowadays many processors come with an integrated system with the only purpose to support debugging and monitoring of the chip. The debugging system can be seen as a separate layer integrated on top of the system, only running in the background without affecting the the target system. In the hunt for higher performance and at the same time higher visibility this solution can be of big interest for software tool vendors and software designers. This master thesis is divided into two parts where the first one gives an overview of the concept with multi-core processors and problems with developing efficient software for them. It also addresses why a hardware based debugging and analyzing system can be beneficial during software development. In the second part a design is developed for a hardware based debugging system, implemented in a state of the art multi-core processor from Freescale. The parallel software running on the multicore processor is executed on top of Enea’s real time operating system OSE.
29
Ansariramandi, Saeed. "Automated Debugging in a Trading System." Thesis, KTH, Skolan för informations- och kommunikationsteknik (ICT), 2012. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-90331.
Full textAbstract:
Verifying the reliability and functionality of a complex system like a trading system is highly demanding since failure in such a system can cause serious economic problems. Automated random testing is a good solution to find new and rare failures in such a system. Test cases in random testing usually contain a long sequence of actions that debugging them manually to find the root cause of the failure is a very boring and tiresome task. This thesis aims to create a model for automating the task of the debugging to reduce the failed test case to an equivalent test case that only contains relevant actions that together cause the failure. Delta debugging is the core algorithm of the model that simplifies a failed test case by successive testing. The target of the project is TRADExpress system of Cinnober Financial Technology AB. The model is integrated to the random testing framework of the TRADExpress system.
30
Bunus, Peter. "Debugging techniques for equation-based languages /." Linköping : Univ, 2004. http://www.bibl.liu.se/liupubl/disp/disp2004/tek873s.pdf.
Full text
31
Hirankitti, Visit. "Applying scientific method to program debugging." Thesis, Imperial College London, 1998. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.286338.
Full text
32
Damitio, Moniques Marie-Claude. "Dynamic slicing for debugging distributed programs." Thesis, University of Exeter, 1998. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.243660.
Full text
33
Litt, Jonathan Zachary. "Debugging support for dynamically generated code." Thesis, Massachusetts Institute of Technology, 1997. http://hdl.handle.net/1721.1/42712.
Full textAbstract:
Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 1997.Includes bibliographical references (leaves 44-46).
by Jonathan Zachary Litt.
M.Eng.
34
Mecker, Satyajit Singh. "A simulator for ladder logic debugging." Thesis, Virginia Polytechnic Institute and State University, 1989. http://hdl.handle.net/10919/53232.
Full textAbstract:
A simulator for use in programmable controller ladder logic testing is developed. A simulation language, based on SIMSCRIPT 11.5, to model ladder logic run physical systems is also designed. This System Description Language (SDL) handles simulations of the physical systems and the corresponding ladder-system interactions via the usage of specially designed constructs.
The simulation package uses as input an SDL program file describing the system to be simulated, and a ladder file containing the ladder written to control this system. The simulation processor generates the actual simulation from the description contained in the SDL program file. A ladder scanning procedure approximates the actual programmable controller scan as closely as possible. The simulator also incorporates the ability for the user to dynamically interact with, and control the simulation by manipulating ladder inputs from the keyboard. A rolling timing diagram display of a maximum of 7 elements can be created and continuously updated for viewing purposes.
System simulations of functionally different manufacturing systems are created and run with their respective ladders on the simulator. Different ladders for the same system are compared for evaluating the performance of the control logic of each ladder. These comparisons are based on the viewing of timing diagrams generated by the ladders. Thus, an off-line ladder logic debugging environment is created.Master of Science
35
Khan, Jehandad. "Holistic Abstraction for Distributed Network Debugging." Diss., Virginia Tech, 2018. http://hdl.handle.net/10919/93500.
Full textAbstract:
Computer networks are engineered for performance and flexibility, delivering billions of packets per second with high reliability, until they fail. It is during such time of crisis that debugging and troubleshooting come to the forefront, however, the focus on performance results in design tradeoffs that make it challenging to troubleshoot them. This dissertation hypothesizes that a view of the network as a single entity solves the above problems, without compromising either performance or visibility. The primary contributions are 1) a topology oblivious network abstraction for performance monitoring and troubleshooting, 2) transformation of the network abstract query to device local semantics, 3) optimizations for reducing state collection overhead, and 4) global state semantics in the proposed query language easing expression of network queries. Abstracting the entire system as an entity simplifies the debugging process, making possible comprehensive root-cause analysis and exonerating the network administrator from dealing with many devices, delivering gains in productivity and efficiency. By merging network topology information with state collection, this thesis provides a new way to look at the network monitoring and troubleshooting problem. Such an amalgamation allows the translation of a performance query expressed in a domain specific language to small pieces of code operating on different devices in the network collecting necessary state. This merging results in lesser overhead per switch and reduces the strain on devices and provides a simple abstraction to the administrator.PHD
36
Shomper, Keith A. "Visualizing program variable data for debugging /." The Ohio State University, 1993. http://rave.ohiolink.edu/etdc/view?acc_num=osu1487848531364488.
Full text
37
Choi, Jong-Deok. "Parallel program debugging with flowback analysis." Madison, Wis. : University of Wisconsin-Madison, Computer Sciences Dept, 1989. http://catalog.hathitrust.org/api/volumes/oclc/20839575.html.
Full text
38
Chu, Justin. "CONTEXT-AWARE DEBUGGING FOR CONCURRENT PROGRAMS." UKnowledge, 2017. https://uknowledge.uky.edu/cs_etds/61.
Full textAbstract:
Concurrency faults are difficult to reproduce and localize because they usually occur under specific inputs and thread interleavings. Most existing fault localization techniques focus on sequential programs but fail to identify faulty memory access patterns across threads, which are usually the root causes of concurrency faults. Moreover, existing techniques for sequential programs cannot be adapted to identify faulty paths in concurrent programs. While concurrency fault localization techniques have been proposed to analyze passing and failing executions obtained from running a set of test cases to identify faulty access patterns, they primarily focus on using statistical analysis. We present a novel approach to fault localization using feature selection techniques from machine learning. Our insight is that the concurrency access patterns obtained from a large volume of coverage data generally constitute high dimensional data sets, yet existing statistical analysis techniques for fault localization are usually applied to low dimensional data sets. Each additional failing or passing run can provide more diverse information, which can help localize faulty concurrency access patterns in code. The patterns with maximum feature diversity information can point to the most suspicious pattern. We then apply data mining technique and identify the interleaving patterns that are occurred most frequently and provide the possible faulty paths. We also evaluate the effectiveness of fault localization using test suites generated from different test adequacy criteria. We have evaluated Cadeco on 10 real-world multi-threaded Java applications. Results indicate that Cadeco outperforms state-of-the-art approaches for localizing concurrency faults.
39
Elms, Kim. "Debugging optimised code using function interpretation." Thesis, Queensland University of Technology, 1999.
Find full text
40
Petrovay, Gabriel. "XQuery (scripting) debugging IDE and engine support /." Zürich : ETH, Swiss Federal Institute of Technology Zurich, Department of Computer Science, Databases and Information Systems Group, 2008. http://e-collection.ethbib.ethz.ch/show?type=dipl&nr=366.
Full text
41
Sjöholm, Klas. "Debugging Equation-Based Languages in OpenModelica Environment." Thesis, Department of Computer and Information Science, 2009. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-19866.
Full textAbstract:
The need for debugging tools for declarative programming languages has increased due to the rapid development of modeling and simulation tools/programs. Declarative equation-based programming languages have the problem of equation systems being over-, or under-constrained. This means that the system of equations has more equations than variables or more variables than equations respectively, making the system of equations unsolvable. In this study a static debugger is implemented in OpenModelica compiler for the equation-based programming language Modelica to make it easier for the programmer or modeler to locate the equation/s causing the unconstrained system of equations. The debugging techniques used by the debugger are developed by Peter Bunus. Those techniques are able to detect unconstrained systems of equations and give solutions by identifying the minimal set ofequation/s that should be removed or which variable/s should be added to an equation/s to make the system solvable. In this study the debugging techniques for detecting and giving a solution for over-constrained system of equations are shown suitable to be used for the programming language Modelica in the OpenModelica compiler.
42
Siverskog, Jacob. "Evaluation of partial reconfiguration for FPGA debugging." Thesis, Linköping University, Computer Engineering, 2010. http://urn.kb.se/resolve?urn=urn:nbn:se:liu:diva-57714.
Full textAbstract:
Reconfigurable computing is an old concept that during the past couple of decades has become increasingly popular. The concept combines the flexibility of software with the performance of hardware. One important contributing factor to the uprising in popularity is the presence of FPGAs (field-programmable gate arrays), which realize the concept by allowing the hardware to be reconfigured dynamically. The current state of reconfigurable computing is discussed further in the thesis.
Debugging is a vital part in the development of a hardware design. It can be done in several ways depending on the situation. The most common way is to perform simulations but in some cases the fault-finding has to be done when the design is implemented in hardware.
In this thesis a framework concept is designed that utilizes and evaluates some of the reconfigurable computing ideas. The framework provides debugging possibilities for FPGA designs in a novel way, with a modular system where each module provide means to aid finding a specific fault. The framework is added to an existing design, and offers the user a glimpse into the design behavior and the hardware it runs on.
One of the debug modules will be released separately under a free license. It allows the developer to see the contents of the memories in a design without requiring special debugging equipment.
43
Akgul, Tankut. "Assembly Instruction Level Reverse Execution for Debugging." Diss., Georgia Institute of Technology, 2004. http://hdl.handle.net/1853/5249.
Full textAbstract:
Reverse execution can be defined as a method which recovers the states that a program attains during its execution. Therefore, reverse execution eliminates the need for repetitive program restarts every time a bug location is missed. This potentially shortens debug time considerably.
This thesis presents a new approach which, for the first time ever (to the best of the author's knowledge), achieves reverse execution at the assembly instruction level on general purpose processors via execution of a reverse program. A reverse program almost always regenerates destroyed states rather than restoring them from a record. Furthermore, a reverse program provides assembly instruction by assembly instruction execution in the backward direction. This significantly reduces state saving and thus decreases the associated memory and time costs of reverse execution support.
Furthermore, this thesis presents a new dynamic slicing algorithm that is built on top of assembly instruction level reverse execution. Dynamic slicing is a technique which isolates the code parts that influence an erroneous variable at a program point. The algorithm presented in this thesis achieves dynamic slicing via execution of a reduced reverse program. A reduced reverse program is obtained from a full reverse program by omitting the instructions that recover states irrelevant to the dynamic slice under consideration. This provides a reverse execution capability along a designated dynamic slice only. The use of a reduced reverse program for dynamic slicing removes the need for runtime execution trajectories.
The methodology of this thesis has been implemented on a PowerPC processor with a custom made debugger. As compared to previous work, all of which heavily use state saving techniques, the experimental results show up to 2206X reduction in runtime memory usage, up to 403X reduction in forward execution time overhead and up to 2.32X reduction in forward execution time for the tested benchmarks. Measurements on the selected benchmarks also indicate that the dynamic slicing method presented in this thesis can achieve up to six orders of magnitude (1,928,500X) speedups in reverse execution along the dynamic slice as compared to full-scale reverse execution.
44
Brickner, Hans. "A research on debugging tools’ platform independency." Thesis, KTH, Skolan för informations- och kommunikationsteknik (ICT), 2011. http://urn.kb.se/resolve?urn=urn:nbn:se:kth:diva-37231.
Full textAbstract:
Debugging of embedded systems is costly and time consuming,but imperative to system design. There are many different requirements on embedded systems and complying with these requirements has lead to many different kinds, and different configurations of embedded systems. The vast array of embedded systems, and the ever increasing complexity of the systems make debugging a growing challenge. Different domains impose different requirements on the systems and as embedded system pervade in our society, new requirement are introduced. ENEA’s products target various domains as: telecom, medical and the automotive domain. Targeting these three domains means that ENEA’s products need to comply with various, and stringent requirements. A debugging tool used in a tool chain like the tool chain developed in the iFEST project, as intended for ENEA’s debugging tool Optima, needs to support various debugging methods, ranging from software debugging methods to methods utilizing embedded hardware for debugging. The need for debugging tools in a tool chain to support various debugging methods lead to this master’s thesis, at and for ENEA. This thesis investigates methods to debug embedded systems in order to define enhancements of the debugging tool Optima that enables Optima to debug various systems and to debug all systems in ENEA’s target domains. The thesis is divided into two parts: a pre-study and a development part. The pre-study covers debugging of embedded systems by studying articles and ENEA’s operating system OSE and debugging tool Optima. Conclusion drawn from the study of methods to debug embedded systems and the study of the debugging support in Optima, show that Optima needs to utilize embedded hardware for debugging. Updates for Optima that enable utilization of embedded hardware for debugging are designed and implemented in the development part of the thesis. Hardware debugging facilities in the development platform targeted in this thesis are not fully incorporated. The lack of hardware debugging support in the platform makes it infeasible to debug the platform from software running on the processor core, and thus infeasible to improve Optima’s debugging capability by enhancing standard OSE debugging facilities to utilize embedded hardware for debugging. An external debugging tool, JTAG, is required to access the embedded debugging hardware in the target platform and to enable non-intrusive debugging.
45
Poutakidis, David Alexander, and davpout@cs rmit edu au. "Debugging Multi-Agent Systems With Design Documents." RMIT University. Computer Science and Information Technology, 2008. http://adt.lib.rmit.edu.au/adt/public/adt-VIT20081205.114106.
Full textAbstract:
Debugging multi-agent systems, which are concurrent, distributed, and consist of complex components is difficult, yet crucial. The development of these complex systems is supported by agent-oriented software engineering methodologies which utilise agents as the central design metaphor. The systems that are developed are inherently complex since the components of these systems may interact in flexible and sophisticated ways and traditional debugging techniques are not appropriate. Despite this, very little effort has been applied to developing appropriate debugging tools and techniques. Debugging multi-agent systems without good debugging tools is highly impractical and without suitable debugging support developing and maintaining multi-agent systems will be more difficult than it need be. In this thesis we propose that the debugging process can be supported by following an agent-oriented design methodology, and then using the developed design artifacts in the debugging phase. We propose a domain independent debugging framework which comprises the developed processes and components that are necessary in using design artifacts as debugging artifacts. Our approach is to take a non-formal design artifact, such as an AUML protocol design, and encode it in a machine interpretable manner such that the design can be used as a model of correct system behaviour. These models are used by a run-time debugging system to compare observed behaviour against specified behaviour. We provide details for transforming two design artifact types into equivalent debugging artifacts and show how these can be used to detect bugs. During a debugging episode in which a bug has been identified our debugging approach can provide detailed information about the possible reason for the bug occurring. To determine if this information was useful in helping to debug programs we undertook a thorough empirical study and identified that use of the debugging tool translated to an improvement in debugging performance. We conclude that the debugging techniques developed in this thesis provide effective debugging support for multi-agent systems and by having an extensible framework new design artifacts can be explored and as translations are developed they can be added to the debugging system.
46
Krishnan, Krishna Kumar. "System based ladder logic simulation and debugging." Thesis, This resource online, 1991. http://scholar.lib.vt.edu/theses/available/etd-11072008-063418/.
Full text
47
Westman, Patrik. "Debugging methods - applied on networking operating systems." Thesis, Umeå universitet, Institutionen för datavetenskap, 2013. http://urn.kb.se/resolve?urn=urn:nbn:se:umu:diva-81115.
Full textAbstract:
As the computer hardware has become more powerful the parallel and distributed programming has become increasingly popular. The debugging of these systems are however complex. It is common that when debugging such systems only print-statements are used since debugging environments may be hard, or impossible to run on the target systems.The aim of this thesis is to provide an understanding of debugger architecture and the most commonly used debugging techniques and where these are used. This will not give a complete understanding of them, but hopefully questions will be raised that may aid users to expand their debugging operations and question the techniques that they use.Some of these debugging techniques will be applied to give suggestion of a method which allow debugging of systems with several processes where dependencies between the processes are high. This method is presented in chapter 4 and involves a remote debugging solution using the GDB debugger as a back-end debugger.
48
Eaton, Anthony John. "Graphical debugging and validation of parallel programs." Thesis, University of Liverpool, 1993. http://ethos.bl.uk/OrderDetails.do?uin=uk.bl.ethos.357386.
Full text
49
Faddegon, Maarten. "Algorithmic debugging for complex lazy functional programs." Thesis, University of Kent, 2017. https://kar.kent.ac.uk/63869/.
Full textAbstract:
An algorithmic debugger finds defects in programs by systematic search. It relies on the programmer to direct the search by answering a series of yes/no questions about the correctness of specific function applications and their results. Existing algorithmic debuggers for a lazy functional language work well for small simple programs but cannot be used to locate defects in complex programs for two reasons: Firstly, to collect the information required for algorithmic debugging existing debuggers use different but complex implementations. Therefore, these debuggers are hard to maintain and do not support all the latest language features. As a consequence, programs with unsupported language features cannot be debugged. Also inclusion of a library using unsupported languages features can make algorithmic debugging unusable even when the programmer is not interested in debugging the library. Secondly, algorithmic debugging breaks down when the size or number of questions is too great for the programmer to handle. This is a pity, because, even though algorithmic debugging is a promising method for locating defects, many real-world programs are too complex for the method to be usuable. I claim that the techniques in in this thesis make algorithmic debugging useable for a much more complex lazy functional programs. I present a novel method for collecting the information required for algorithmically debugging a lazy functional program. The method is non-invasive, uses program annotations in suspected modules only and has a simple implementation. My method supports all of Haskell, including laziness, higher-order functions and exceptions. Future language extensions can be supported without changes, or with minimal changes, to the implementation of the debugger. With my method the programmer can focus on untrusted code -- lots of trusted libraries are unaffected. This makes traces, and hence the amount of questions that needs to be answered, more manageable. I give a type-generic definition to support custom types defined by the programmer. Furthermore, I propose a method that re-uses properties to answer automatically some of the questions arising during algorithmic debugging, and to replace others by simpler questions. Properties may already be present in the code for testing; the programmer can also encode a specification or reference implementation as a property, or add a new property in response to a statement they are asked to judge.
50
Nigam, Atish 1981. "Analytical techniques for debugging pervasive computing environments." Thesis, Massachusetts Institute of Technology, 2004. http://hdl.handle.net/1721.1/17962.
Full textAbstract:
Thesis (M. Eng.)--Massachusetts Institute of Technology, Dept. of Electrical Engineering and Computer Science, 2004.Includes bibliographical references (p. 63-65).
User level debugging of pervasive environments is important as it provides the ability to observe changes that occur in a pervasive environment and fix problems that result from these changes, especially since pervasive environments may from time to time exhibit unexpected behavior. Simple keepalive messages can not always uncover the source of this behavior because systems can be in an incorrect state while continuing to output information or respond to basic queries. The traditional approach to debugging distributed systems is to instrument the entire environment. This does not work when the environments are cobbled together from systems built around different operating systems, programming languages or platforms. With systems from such disparate backgrounds, it is hard to create a stable pervasive environment. We propose to solve this problem by requiring each system and component to provide a health metric that gives an indication of its current status. Our work has shown that, when monitored at a reasonable rate, simple and cheap metrics can reveal the cause of many problems within pervasive environments. The two metrics that will be focused on in this thesis are transmission rate and transmission data analysis. Algorithms for implementing these metrics, within the stated assumptions of pervasive environments, will be explored along with an analysis of these implementations and the results they provided. Furthermore, a system design will be described in which the tools used to analyze the metrics compose an out of bound monitoring system that retains a level of autonomy from the pervasive environment. The described system provides many advantages and additionally operates under the given assumptions regarding the resources available
(cont.) within a pervasive environment.
by Atish Nigam.
M.Eng.