{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/69361"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/69361","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Design of Systems With Concurrent Error Detection Using Software Redundancy","abstract":"Self-checking programming is a system level concurrent error detection technique. This approach achieves error detection by introducing software redundancy in the form of executable assertion into the program to check the correct operation of the system during its execution. Both hardware and software faults that affect the specified behavior of the program therefore can be detected.","abstract_html":"Self-checking programming is a system level concurrent error detection technique. This approach achieves error detection by introducing software redundancy in the form of executable assertion into the program to check the correct operation of the system during its execution. Both hardware and software faults that affect the specified behavior of the program therefore can be detected.","abstract_has_math":false,"creators":["Hua, Kien Anh"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"Ph.D.","degree_level":"Dissertation","degree_discipline":"Electrical Engineering","degree_department":null,"school":null,"contributors":[],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2014,"date_issued":"2014-12-15T19:05:19Z","date_published":"2014-12-15T19:05:19Z","updated_at":"2026-07-22T22:26:00Z","subjects":["Computer Science"],"languages":[],"rights":[],"rights_urls":[],"identifier_entries":[{"key":"dc:identifier","label":"Identifier","values":["(UMI)AAI8721662"],"render_values":[{"text":"(UMI)AAI8721662","href":null,"code":true}]}]},"links":{"outbound_url":"http://hdl.handle.net/2142/69361","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:creator","label":"Author","values":["Hua, Kien Anh"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2014-12-15T19:05:19Z","10000-01-01","1987"]},{"key":"dc:type","label":"Dc Type","values":["text"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Electrical Engineering"]},{"key":"thesis:degree_level","label":"Degree Level","values":["Dissertation"]},{"key":"thesis:degree_name","label":"Degree Name","values":["Ph.D."]},{"key":"thesis:institution_name","label":"Thesis Institution Name","values":["University of Illinois at Urbana-Champaign"]}]},{"id":"subjects_keywords","label":"Subjects and Keywords","entries":[{"key":"dc:subject","label":"Dc Subject","values":["Computer Science"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/69361","(UMI)AAI8721662"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["Self-checking programming is a system level concurrent error detection technique. This approach achieves error detection by introducing software redundancy in the form of executable assertion into the program to check the correct operation of the system during its execution. Both hardware and software faults that affect the specified behavior of the program therefore can be detected.","This thesis deals with a theoretical and experimental study of the scheme of self-checking programming. It addresses three issues. First, it deals with the design issues of self-checking programs. Two approaches are presented. The first approach derives the assertions from the text of the program design based on a set of formal transformation rules. The second approach employs data encoding schemes in which the program is designed to process information encoded in some error detecting code, and error detection is performed by observing the program coded output. Examples are given to illustrate the application of these techniques.","The second part deals with the development of a technique which can be used to analyze the error coverage of the proposed concurrent error detection scheme. The technique is essentially a fault simulation method. Simulated faults are introduced into the program at various levels (target programming language level or assembly language level) to produce mutant programs. These mutants are then executed to measure the ability of the set of assertions to distinguish the program from its mutants. This strategy is used in the experiments to study the effectiveness of five sample self-checking programs that include a navigation program of about 1000 lines of code. The results show that self-checking programming is an inexpensive and effective approach to provide concurrent error detection.","The automation issues are addressed in the last part of the thesis. The application of automated reasoning techniques to the problem of self-checking program design is discussed. A knowledge base is employed to support the understanding of the program design. The knowledge that includes programming knowledge and domain knowledge is presented in clause form in the Knowledge Base. A program design is also stored internally as clauses, and the assertions are derived by applying logic resolution and demodulation to these clauses.","Made available in DSpace on 2014-12-15T19:05:19Z (GMT). No. of bitstreams: 1 8721662.pdf: 4550641 bytes, checksum: 9e35881818b3ed18d897a29a048dbffe (MD5) Previous issue date: 1987","Embargo set by: Seth Robbins for item 69527 Lift date: Forever Reason: Restricted to the U of I community idenfinitely during batch ingest of legacy ETDs","Restricted to the U of I community idenfinitely during batch ingest of legacy ETDs","U of I Only","125 p.","Thesis (Ph.D.)--University of Illinois at Urbana-Champaign, 1987."]},{"key":"dc:title","label":"Title","values":["Design of Systems With Concurrent Error Detection Using Software Redundancy"]}]}],"canonical_facts":{"dc:creator":["Hua, Kien Anh"],"dc:date":["2014-12-15T19:05:19Z","10000-01-01","1987"],"dc:description":["Self-checking programming is a system level concurrent error detection technique. This approach achieves error detection by introducing software redundancy in the form of executable assertion into the program to check the correct operation of the system during its execution. Both hardware and software faults that affect the specified behavior of the program therefore can be detected.","This thesis deals with a theoretical and experimental study of the scheme of self-checking programming. It addresses three issues. First, it deals with the design issues of self-checking programs. Two approaches are presented. The first approach derives the assertions from the text of the program design based on a set of formal transformation rules. The second approach employs data encoding schemes in which the program is designed to process information encoded in some error detecting code, and error detection is performed by observing the program coded output. Examples are given to illustrate the application of these techniques.","The second part deals with the development of a technique which can be used to analyze the error coverage of the proposed concurrent error detection scheme. The technique is essentially a fault simulation method. Simulated faults are introduced into the program at various levels (target programming language level or assembly language level) to produce mutant programs. These mutants are then executed to measure the ability of the set of assertions to distinguish the program from its mutants. This strategy is used in the experiments to study the effectiveness of five sample self-checking programs that include a navigation program of about 1000 lines of code. The results show that self-checking programming is an inexpensive and effective approach to provide concurrent error detection.","The automation issues are addressed in the last part of the thesis. The application of automated reasoning techniques to the problem of self-checking program design is discussed. A knowledge base is employed to support the understanding of the program design. The knowledge that includes programming knowledge and domain knowledge is presented in clause form in the Knowledge Base. A program design is also stored internally as clauses, and the assertions are derived by applying logic resolution and demodulation to these clauses.","Made available in DSpace on 2014-12-15T19:05:19Z (GMT). No. of bitstreams: 1 8721662.pdf: 4550641 bytes, checksum: 9e35881818b3ed18d897a29a048dbffe (MD5) Previous issue date: 1987","Embargo set by: Seth Robbins for item 69527 Lift date: Forever Reason: Restricted to the U of I community idenfinitely during batch ingest of legacy ETDs","Restricted to the U of I community idenfinitely during batch ingest of legacy ETDs","U of I Only","125 p.","Thesis (Ph.D.)--University of Illinois at Urbana-Champaign, 1987."],"dc:identifier":["http://hdl.handle.net/2142/69361","(UMI)AAI8721662"],"dc:subject":["Computer Science"],"dc:title":["Design of Systems With Concurrent Error Detection Using Software Redundancy"],"dc:type":["text"],"thesis:degree_discipline":["Electrical Engineering"],"thesis:degree_level":["Dissertation"],"thesis:degree_name":["Ph.D."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:26:00Z"}