{"id":{"repo_id":"uiuc","oai_identifier":"oai:www.ideals.illinois.edu:2142/101201"},"canonical_url":"https://search.dev.ndltd.org/etd/uiuc/oai:www.ideals.illinois.edu:2142/101201","repository":{"repo_id":"uiuc","name":"University of Illinois - Urbana-Champaign","base_url":"https://www.ideals.illinois.edu/oai-pmh"},"display":{"title":"Toward automatic programming","abstract":"Programming, the act of creating and changing software source code, should be a collaborative process between humans and computers. This dissertation shows a general approach and two techniques that bring us closer to this goal. The general approach is inspired by human programmers: they learn how to transform code by looking at similar past transformation instances, then they change new code by stringing together several fine-grained transformations. First, we give a technique for inferring abstract program transformations from concrete code examples. The transformations are expressed as formal rules in a term rewriting language with contexts, and they are inferred from examples via a novel anti-unification algorithm. For evaluation, we use the technique to successfully infer 15 JavaScript linting rules. Second, we give a technique for searching through compositions of program transformations to satisfy a goal. The search is an evolutionary algorithm with the fitness function defined over the code and the code transformations as mutations. For evaluation, we apply the technique to the problem of automatically translating imperative, sequential programs to functional MapReduce programs. The algorithm successfully finds efficient MapReduce implementations for programs with complex indirect accesses, such as WordCount.","abstract_html":"Programming, the act of creating and changing software source code, should be a collaborative process between humans and computers. This dissertation shows a general approach and two techniques that bring us closer to this goal. The general approach is inspired by human programmers: they learn how to transform code by looking at similar past transformation instances, then they change new code by stringing together several fine-grained transformations. First, we give a technique for inferring abstract program transformations from concrete code examples. The transformations are expressed as formal rules in a term rewriting language with contexts, and they are inferred from examples via a novel anti-unification algorithm. For evaluation, we use the technique to successfully infer 15 JavaScript linting rules. Second, we give a technique for searching through compositions of program transformations to satisfy a goal. The search is an evolutionary algorithm with the fitness function defined over the code and the code transformations as mutations. For evaluation, we apply the technique to the problem of automatically translating imperative, sequential programs to functional MapReduce programs. The algorithm successfully finds efficient MapReduce implementations for programs with complex indirect accesses, such as WordCount.","abstract_has_math":false,"creators":["Radoi, Cosmin A"],"institution":"University of Illinois at Urbana-Champaign","degree_name":"Ph.D.","degree_level":"Dissertation","degree_discipline":"Computer Science","degree_department":null,"school":null,"contributors":["Roşu, Grigore","Padua, David","Dig, Danny","Sridharan, Manu"],"advisors":[],"committee_chairs":[],"committee_members":[],"year":2018,"date_issued":"2018-09-04T20:36:49Z","date_published":"2018-09-04T20:36:49Z","updated_at":"2026-07-22T22:24:38Z","subjects":["program transformation automatic programming generalization evolutionary algorithms"],"languages":["en"],"rights":["Copyright 2018 Cosmin Radoi"],"rights_urls":[],"identifier_entries":[]},"links":{"outbound_url":"http://hdl.handle.net/2142/101201","outbound_label":"Handle","outbound_source":"dc:identifier"},"metadata_groups":[{"id":"people","label":"People","entries":[{"key":"dc:contributor","label":"Contributor","values":["Roşu, Grigore","Padua, David","Dig, Danny","Sridharan, Manu"]},{"key":"dc:creator","label":"Author","values":["Radoi, Cosmin A"]}]},{"id":"academic_context","label":"Academic Context","entries":[{"key":"dc:date","label":"Dc Date","values":["2018-09-04T20:36:49Z","2020-09-05T09:15:13Z","2018-04-20","2018-05"]},{"key":"dc:type","label":"Dc Type","values":["text"]},{"key":"thesis:degree_discipline","label":"Discipline","values":["Computer Science"]},{"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":["program transformation automatic programming generalization evolutionary algorithms"]}]},{"id":"language_rights","label":"Language and Rights","entries":[{"key":"dc:language","label":"Dc Language","values":["en"]},{"key":"dc:rights","label":"Dc Rights","values":["Copyright 2018 Cosmin Radoi"]}]},{"id":"identifiers","label":"Identifiers","entries":[{"key":"dc:identifier","label":"Identifier","values":["http://hdl.handle.net/2142/101201"]}]},{"id":"additional","label":"Additional Metadata","entries":[{"key":"dc:description","label":"Description","values":["Programming, the act of creating and changing software source code, should be a collaborative process between humans and computers. This dissertation shows a general approach and two techniques that bring us closer to this goal. The general approach is inspired by human programmers: they learn how to transform code by looking at similar past transformation instances, then they change new code by stringing together several fine-grained transformations. First, we give a technique for inferring abstract program transformations from concrete code examples. The transformations are expressed as formal rules in a term rewriting language with contexts, and they are inferred from examples via a novel anti-unification algorithm. For evaluation, we use the technique to successfully infer 15 JavaScript linting rules. Second, we give a technique for searching through compositions of program transformations to satisfy a goal. The search is an evolutionary algorithm with the fitness function defined over the code and the code transformations as mutations. For evaluation, we apply the technique to the problem of automatically translating imperative, sequential programs to functional MapReduce programs. The algorithm successfully finds efficient MapReduce implementations for programs with complex indirect accesses, such as WordCount.","Submission published under a 24 month embargo labeled 'U of I Access', the embargo will last until 2020-05-01","The student, Cosmin Radoi, accepted the attached license on 2018-04-20 at 16:10.","The student, Cosmin Radoi, submitted this Dissertation for approval on 2018-04-20 at 16:15.","This Dissertation was approved for publication on 2018-04-20 at 16:49.","DSpace SAF Submission Ingestion Package generated from Vireo submission #12392 on 2018-08-31 at 17:21:07","Made available in DSpace on 2018-09-04T20:36:49Z (GMT). No. of bitstreams: 2 RADOI-DISSERTATION-2018.pdf: 2226442 bytes, checksum: 4c05bf717b9d797f97a22ca31f3f078f (MD5) LICENSE.txt: 4209 bytes, checksum: e26b01367961da755c486f984ddf7211 (MD5) Previous issue date: 2018-04-20","Embargo set by: Seth Robbins for item 107285 Lift date: 2020-09-04T20:37:00Z Reason: Author requested U of Illinois access only (OA after 2yrs) in Vireo ETD system","Embargo set by: Seth Robbins for item 107285 Lift date: 2020-09-04T20:42:08Z Reason: Author requested U of Illinois access only (OA after 2yrs) in Vireo ETD system","U of I Only Restriction Lifted for Item 107285 on 2020-09-05T09:15:13Z."]},{"key":"dc:format","label":"Dc Format","values":["application/pdf"]},{"key":"dc:title","label":"Title","values":["Toward automatic programming"]}]}],"canonical_facts":{"dc:contributor":["Roşu, Grigore","Padua, David","Dig, Danny","Sridharan, Manu"],"dc:creator":["Radoi, Cosmin A"],"dc:date":["2018-09-04T20:36:49Z","2020-09-05T09:15:13Z","2018-04-20","2018-05"],"dc:description":["Programming, the act of creating and changing software source code, should be a collaborative process between humans and computers. This dissertation shows a general approach and two techniques that bring us closer to this goal. The general approach is inspired by human programmers: they learn how to transform code by looking at similar past transformation instances, then they change new code by stringing together several fine-grained transformations. First, we give a technique for inferring abstract program transformations from concrete code examples. The transformations are expressed as formal rules in a term rewriting language with contexts, and they are inferred from examples via a novel anti-unification algorithm. For evaluation, we use the technique to successfully infer 15 JavaScript linting rules. Second, we give a technique for searching through compositions of program transformations to satisfy a goal. The search is an evolutionary algorithm with the fitness function defined over the code and the code transformations as mutations. For evaluation, we apply the technique to the problem of automatically translating imperative, sequential programs to functional MapReduce programs. The algorithm successfully finds efficient MapReduce implementations for programs with complex indirect accesses, such as WordCount.","Submission published under a 24 month embargo labeled 'U of I Access', the embargo will last until 2020-05-01","The student, Cosmin Radoi, accepted the attached license on 2018-04-20 at 16:10.","The student, Cosmin Radoi, submitted this Dissertation for approval on 2018-04-20 at 16:15.","This Dissertation was approved for publication on 2018-04-20 at 16:49.","DSpace SAF Submission Ingestion Package generated from Vireo submission #12392 on 2018-08-31 at 17:21:07","Made available in DSpace on 2018-09-04T20:36:49Z (GMT). No. of bitstreams: 2 RADOI-DISSERTATION-2018.pdf: 2226442 bytes, checksum: 4c05bf717b9d797f97a22ca31f3f078f (MD5) LICENSE.txt: 4209 bytes, checksum: e26b01367961da755c486f984ddf7211 (MD5) Previous issue date: 2018-04-20","Embargo set by: Seth Robbins for item 107285 Lift date: 2020-09-04T20:37:00Z Reason: Author requested U of Illinois access only (OA after 2yrs) in Vireo ETD system","Embargo set by: Seth Robbins for item 107285 Lift date: 2020-09-04T20:42:08Z Reason: Author requested U of Illinois access only (OA after 2yrs) in Vireo ETD system","U of I Only Restriction Lifted for Item 107285 on 2020-09-05T09:15:13Z."],"dc:format":["application/pdf"],"dc:identifier":["http://hdl.handle.net/2142/101201"],"dc:language":["en"],"dc:rights":["Copyright 2018 Cosmin Radoi"],"dc:subject":["program transformation automatic programming generalization evolutionary algorithms"],"dc:title":["Toward automatic programming"],"dc:type":["text"],"thesis:degree_discipline":["Computer Science"],"thesis:degree_level":["Dissertation"],"thesis:degree_name":["Ph.D."],"thesis:institution_name":["University of Illinois at Urbana-Champaign"]},"updated_at":"2026-07-22T22:24:38Z"}