DOCSLIB.ORG

Practical Program Repair Via Bytecode Mutation

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Practical Program Repair Via Bytecode Mutation Practical Program Repair via Bytecode Mutation Ali Ghanbari and Lingming Zhang The University of Texas at Dallas {ali.ghanbari,lingming.zhang}@utdallas.edu ABSTRACT equivalent to developer patches) or suggesting patches, that may Software debugging is tedious, time-consuming, and even error- guide the debuggers to fix the bugs faster. Thus, APR has beenthe prone by itself. So, various automated debugging techniques have subject of intense research in spite of being a young research area. been proposed in the literature to facilitate the debugging process. Based on the actions they take for fixing a bug, state-of-the-art Automated Program Repair (APR) is one of the most recent ad- APR techniques can be divided into two broad categories: (1) tech- vances in automated debugging, and can directly produce patches niques that monitor the dynamic execution of a program to find for buggy programs with minimal human intervention. Although deviations from certain specifications, and then heal the program various advanced APR techniques (including those that are either by modifying its runtime state in case of any abnormal behavior search-based or semantic-based) have been proposed, the simplis- [43, 56]; (2) so-called generate-and-validate techniques that modify tic mutation-based APR technique, which simply uses pre-defined the code representation of the programs based on various rules/tech- mutation operators (e.g., changing a>=b into a>b) to mutate pro- niques, and then use either test cases or some formal specification grams for finding patches, has not yet been thoroughly studied. (such as code contracts) as an oracle to validate each generated can- In this paper, we implement the first practical bytecode-level APR didate patch, and find plausible patches (i.e., the patches that can technique, PraPR, and present the first extensive study on fixing pass all the tests/checks) [16, 18, 19, 23, 28, 36, 41, 42, 47, 51, 55, 62, real-world bugs (e.g., Defects4J bugs) using bytecode mutation. The 68, 73]. Among these, generate-and-validate techniques, especially experimental results show that surprisingly even PraPR with only those that are based on test cases, have gained popularity as testing the basic traditional mutators can produce genuine patches for 18 is the prevalent method for detecting software bugs, while very few bugs. Furthermore, with our augmented mutators, PraPR is able software systems are based on rigorous, formal specifications. to produce genuine patches for 43 bugs, significantly outperform- It is worth noting that, lately, multiple APR research papers ing state-of-the-art APR. It is also an order of magnitude faster, get published in top-notch Software Engineering conferences and indicating a promising future for bytecode-mutation-based APR. journals each year, introducing various delicately designed and/or implemented APR techniques. With such state-of-the-art APR tech- ACM Reference Format: niques, more and more real bugs can be fixed fully automatically, Ali Ghanbari and Lingming Zhang. 2018. Practical Program Repair via Bytecode Mutation. In Proceedings of ACM Conference (Conference’17). ACM, e.g., the most recent APR technique published in ICSE’18 [68] has New York, NY, USA, 14 pages. https://doi.org/10.1145/nnnnnnn.nnnnnnn been reported to produce genuine patches for 22 bugs of Defects4J (a set of real-world Java programs widely used for evaluating APR 1 INTRODUCTION techniques [31]). Despite the success of recent APR techniques, as also highlighted in a recent survey paper [22], currently we Software systems are ubiquitous in today’s world; most of our have a scattered collection of findings and innovations with no activities, and sometimes even our lives, depend on computers thorough evaluation of the techniques or some clear relationship controlled by the software. Unfortunately, software systems are between them. Actually, it is even not clear how the existing sim- not perfect and often come with bugs. Software debugging is a plistic mutation-based APR [19], which generates program patches difficult activity that consumes over 50% of the development time simply based on a limited set of mutators (also called mutation and effort [7], and it costs the global economy billions of dollars [15]. operators) [10], compares to the state-of-the-art APR techniques. To date, a huge body of research has been dedicated to automated Therefore, in this work, we present the first extensive study of debugging to automatically localize [9, 12, 13, 37, 38, 61, 69, 75, 76] a simplistic program repair approach that applies mutation-like or fix [16, 18, 19, 22, 23, 28, 36, 41–44, 47, 48, 51, 55, 56, 62, 64, arXiv:1807.03512v1 [cs.SE] 10 Jul 2018 patch generation on the widely used Defects4J benchmark pro- 67, 68, 73] software bugs. Among various automated debugging grams. More specifically, we build a practical APR tool named PraPR techniques, Automated Program Repair (APR) techniques aim to (Practical Program Repair) based on JVM bytecode mutation. We directly fix software bugs with minimal human intervention. These stress that although simplistic, PraPR offers various benefits over techniques can significantly speed up the debugging process by the state-of-the-art techniques. First, PraPR is the first bytecode- either synthesizing genuine patches (i.e., the patches semantically level APR technique for Java and all the generated patches can be Permission to make digital or hard copies of all or part of this work for personal or directly validated without compilation, while existing techniques classroom use is granted without fee provided that copies are not made or distributed [16, 18, 19, 23, 28, 36, 41, 42, 47, 51, 55, 62, 68, 73] have to compile for profit or commercial advantage and that copies bear this notice and the full citation 1 on the first page. Copyrights for components of this work owned by others than ACM each candidate patch before validating it . Even though some tech- must be honored. Abstracting with credit is permitted. To copy otherwise, or republish, niques curtail compilation overhead by encoding a group of patches to post on servers or to redistribute to lists, requires prior specific permission and/or a fee. Request permissions from [email protected]. inside a single meta-program, it can still take up to 37 hours to fix Conference’17, July 2017, Washington, DC, USA a Defects4J program due to numerous patch compilations and class © 2018 Association for Computing Machinery. ACM ISBN 978-x-xxxx-xxxx-x/YY/MM...$15.00 1Please note that compilation can be quite expensive especially for type-safe program- https://doi.org/10.1145/nnnnnnn.nnnnnnn ming languages. Conference’17, July 2017, Washington, DC, USA Ali Ghanbari and Lingming Zhang loadings [16]. Second, bytecode-level repair avoids messing up the 2.1 Mutation Testing source code in unexpected ways, and can even be applicable for Mutation testing [10] is a powerful method for assessing the quality fixing code without source code information, e.g., buggy 3rd-party of a given test suite in detecting potential software bugs. Mutation libraries that do not have official patches yet. Third, manipulating testing measures test suite quality via injecting “artificial bugs” into programs at the level of JVM bytecode [39] makes PraPR indepen- the subject programs through mutating it. The basic intuition is that dent of the syntax of a specific target programming language, and the more artificial bugs that a test suite can detect, the more likely makes it applicable to fix programs written in other JVM-based is it to detect potential real bugs, hence the test suite is of higher languages (notably Kotlin [27], Scala [52], and even Groovy [1]). quality [11, 32]. Central to mutation testing is the notion of mutation Lastly, PraPR does not require complex patching rules [36, 41, 73], operator, aka mutator, which is used to generate artificial bugs to complicated computations such as symbolic execution and equation mimic real bugs. Applying a mutator on a program results in a solving [16, 47, 51], or any training/mining [59, 68, 72], making it mutant (or mutation) of the program—a variant of the program that directly applicable for real-world programs and easily adoptable as differs from the original program only in the injected artificial bug, the baseline for future APR techniques. e.g., replacing a+b with a-b in one statement. In first-order mutation We have applied PraPR to fix all the 395 bugs available inDe- testing [29], the mutators can be treated as program transformers fects4J. Surprisingly, even the basic traditional mutators can already that change the meaning of the input program by making small, produce plausible and genuine patches for 113 and 18 bugs, respec- single-pointed changes to it. This implies that the resulting mutants tively. With both the traditional and our augmented simple mutators should also be syntactically valid, and also typeable, for it has to (e.g., replacing field accesses or method invocations), PraPR suc- simulate a valid buggy version of the program under test. This cessfully produces genuine patches for 43 Defects4J bugs, thereby also indicates that the mutators are highly dependent on the target significantly outperforming the state-of-the-art APR techniques programming language. Therefore, given an original program P, (e.g., the most recent CapGen technique published in ICSE’18 [68] mutation testing will generate a set of program variants, M, where can only fix 22 bugs). In addition, thanks to the bytecode-level each element is a valid mutant m. manipulation, PraPR with only single-thread execution is already Given the original program P, and a mutant m 2 M of the pro- 26.1X faster than the state-of-the-art CapGen in terms of per-patch gram, a test suite T is said to kill mutant m if and only if there exists time cost.
Load more

Recommended publications
  • COM 113 INTRO to COMPUTER PROGRAMMING Theory Book
    1 [Type the document title] UNESCO -NIGERIA TECHNICAL & VOCATIONAL EDUCATION REVITALISATION PROJECT -PHASE II NATIONAL DIPLOMA IN COMPUTER TECHNOLOGY Computer Programming COURSE CODE: COM113 YEAR I - SE MESTER I THEORY Version 1: December 2008 2 [Type the document title] Table of Contents WEEK 1 Concept of programming ................................................................................................................ 6 Features of a good computer program ............................................................................................ 7 System Development Cycle ............................................................................................................ 9 WEEK 2 Concept of Algorithm ................................................................................................................... 11 Features of an Algorithm .............................................................................................................. 11 Methods of Representing Algorithm ............................................................................................ 11 Pseudo code .................................................................................................................................. 12 WEEK 3 English-like form .......................................................................................................................... 15 Flowchart .....................................................................................................................................
    [Show full text]
  • Sound Invariant Checking Using Type Modifiers and Object Capabilities
    Sound Invariant Checking Using Type Modifiers and Object Capabilities. Isaac Oscar Gariano Victoria University of Wellington [email protected] Marco Servetto Victoria University of Wellington [email protected] Alex Potanin Victoria University of Wellington [email protected] Abstract In this paper we use pre existing language support for type modifiers and object capabilities to enable a system for sound runtime verification of invariants. Our system guarantees that class invariants hold for all objects involved in execution. Invariants are specified simply as methods whose execution is statically guaranteed to be deterministic and not access any externally mutable state. We automatically call such invariant methods only when objects are created or the state they refer to may have been mutated. Our design restricts the range of expressible invariants but improves upon the usability and performance of our system compared to prior work. In addition, we soundly support mutation, dynamic dispatch, exceptions, and non determinism, while requiring only a modest amount of annotation. We present a case study showing that our system requires a lower annotation burden compared to Spec#, and performs orders of magnitude less runtime invariant checks compared to the widely used ‘visible state semantics’ protocols of D, Eiffel. We also formalise our approach and prove that such pre existing type modifier and object capability support is sufficient to ensure its soundness. 2012 ACM Subject Classification Theory of computation → Invariants, Theory of computation → Program verification, Software and its engineering → Object oriented languages Keywords and phrases type modifiers, object capabilities, runtime verification, class invariants Digital Object Identifier 10.4230/LIPIcs.CVIT.2016.23 1 Introduction Object oriented programming languages provide great flexibility through subtyping and arXiv:1902.10231v1 [cs.PL] 26 Feb 2019 dynamic dispatch: they allow code to be adapted and specialised to behave differently in different contexts.
    [Show full text]
  • Method Proxy-Based AOP in Scala
    Vol. 0, No. 0, Z Method Proxy-Based AOP in Scala Daniel Spiewak and Tian Zhao University of Wisconsin – Milwaukee, fdspiewak,[email protected] This paper describes a fully-functional Aspect-Oriented Programming framework in Scala – a statically typed programming language with object-oriented and func- tional features. This framework is implemented as internal domain-specific lan- guages with syntax that is both intuitive and expressive. The implementation also enforces some static type safety in aspect definitions. 1 INTRODUCTION Aspect-Oriented Programming (AOP) implementations such as AspectJ provide language extensions of pointcuts and advices to insert code of crosscutting concerns into the base program through bytecode transformation. In this paper, we describe a framework to implement an AOP extension to the Scala language [13] using higher-order functions as AOP proxies 1. This framework allows programmers to specify pointcuts and aspects using a Domain Specific Language (DSL) [5] embedded within Scala. Our technique uses Scala’s higher-order functions to intercept method calls with minimal syntactic overhead imposed on the base program. This framework allows developers to define pointcuts by specifying class types and method signatures. The framework also allows access to context variables, while aspects can insert advice code before or after the advised body. The rest of the paper is organized as follows: In Section2, we present the main idea using an example. Section3 explains the syntax of pointcuts and advices. Section4 ex- plains the implementation details. We discuss the benefits and tradeoffs of our framework in Section5. and related works are in Section6. 2 EXAMPLE AOP enables developers to write code that is modularized to a point beyond the capabil- ities of vanilla object-oriented design.
    [Show full text]
  • Defining Computer Program Parts Under Learned Hand's Abstractions Test in Software Copyright Infringement Cases
    Michigan Law Review Volume 91 Issue 3 1992 Defining Computer Program Parts Under Learned Hand's Abstractions Test in Software Copyright Infringement Cases John W.L. Ogilive University of Michigan Law School Follow this and additional works at: https://repository.law.umich.edu/mlr Part of the Computer Law Commons, Intellectual Property Law Commons, and the Judges Commons Recommended Citation John W. Ogilive, Defining Computer Program Parts Under Learned Hand's Abstractions Test in Software Copyright Infringement Cases, 91 MICH. L. REV. 526 (1992). Available at: https://repository.law.umich.edu/mlr/vol91/iss3/5 This Note is brought to you for free and open access by the Michigan Law Review at University of Michigan Law School Scholarship Repository. It has been accepted for inclusion in Michigan Law Review by an authorized editor of University of Michigan Law School Scholarship Repository. For more information, please contact [email protected]. NOTE Defining Computer Program Parts Under Learned Hand's Abstractions Test in Software Copyright Infringement Cases John W.L. Ogilvie INTRODUCTION Although computer programs enjoy copyright protection as pro­ tectable "literary works" under the federal copyright statute, 1 the case law governing software infringement is confused, inconsistent, and even unintelligible to those who must interpret it.2 A computer pro­ gram is often viewed as a collection of different parts, just as a book or play is seen as an amalgamation of plot, characters, and other familiar parts. However, different courts recognize vastly different computer program parts for copyright infringement purposes. 3 Much of the dis­ array in software copyright law stems from mutually incompatible and conclusory program part definitions that bear no relation to how a computer program is actually designed and created.
    [Show full text]
  • AP Computer Science Basic OOP — Implementing Classes
    AP Computer Science Basic OOP — Implementing Classes ORIENTATION Object-oriented programming (OOP) refers to the organization of data into classes, categories that represent a given type of “object.” An object can be a model of a real-life thing like a car, a six-sided die, or a person, or it can be a representation of something more abstract like a point in space, a menu item, or a digital clipboard. An object that belongs to a given class is called an instance of that class, and any instance of a class keeps track of its state using instance variables, or attributes. The object is created when its constructor is called, and can be interacted with by calling its methods, which may access data (accessor methods, or “getters”) or alter the object’s data (mutator methods, or “setters”). There are two important theoretical concepts in OOP: abstraction and encapsulation. Objects and the classes they belong to act as abstractions of the things they represent: a Java class called Person isn’t actually a person, of course, but a simplified representation of a person in terms of a limited number of qualities (name and age, perhaps). Other details such as hair color, nationality, and gender identity aren’t included in our abstraction of a person. Encapsulation refers to the way that a class and its methods hide away the details of a process. Someone using a QuadraticFormula class can call the hasSolutions() method to find out whether their equation has solutions without knowing what a discriminant is. The programmer and the class she has written have hidden that information away in a metaphorical “black box.” Basic OOP consists primarily of implementing classes: writing the JavaDocs, class header, constructors, attributes, and methods for an object as specified.
    [Show full text]
  • Language Translators
    Student Notes Theory LANGUAGE TRANSLATORS A. HIGH AND LOW LEVEL LANGUAGES Programming languages Low – Level Languages High-Level Languages Example: Assembly Language Example: Pascal, Basic, Java Characteristics of LOW Level Languages: They are machine oriented : an assembly language program written for one machine will not work on any other type of machine unless they happen to use the same processor chip. Each assembly language statement generally translates into one machine code instruction, therefore the program becomes long and time-consuming to create. Example: 10100101 01110001 LDA &71 01101001 00000001 ADD #&01 10000101 01110001 STA &71 Characteristics of HIGH Level Languages: They are not machine oriented: in theory they are portable , meaning that a program written for one machine will run on any other machine for which the appropriate compiler or interpreter is available. They are problem oriented: most high level languages have structures and facilities appropriate to a particular use or type of problem. For example, FORTRAN was developed for use in solving mathematical problems. Some languages, such as PASCAL were developed as general-purpose languages. Statements in high-level languages usually resemble English sentences or mathematical expressions and these languages tend to be easier to learn and understand than assembly language. Each statement in a high level language will be translated into several machine code instructions. Example: number:= number + 1; 10100101 01110001 01101001 00000001 10000101 01110001 B. GENERATIONS OF PROGRAMMING LANGUAGES 4th generation 4GLs 3rd generation High Level Languages 2nd generation Low-level Languages 1st generation Machine Code Page 1 of 5 K Aquilina Student Notes Theory 1. MACHINE LANGUAGE – 1ST GENERATION In the early days of computer programming all programs had to be written in machine code.
    [Show full text]
  • 13. Stored-Program Computers
    13. Stored-Program Computers 13.1 Introduction This chapter concentrates on the low-level usage and structure of stored program computers. We focus on a particular hypothetical machine known as the ISC, describing its programming in assembly language. We show how recursion and switch statements are compiled into machine language, and how memory-mapped overlapped I/O is achieved. We also show the logic implement of the ISC, in terms of registers, buses, and finite-state machine controllers. 13.2 Programmer's Abstraction for a Stored-Program Computer By stored-program computer, we mean a machine in which the program, as well as the data, are stored in memory, each word of which can be accessed in uniform time. Most of the high-level language programming the reader has done will likely have used this kind of computer implicitly. However, the program that is stored is not high-level language text. If it were, then it would be necessary to constantly parse this text, which would slow down execution immensely. Instead one of two other forms of storage is used: An abstract syntax representation of the program could be stored. The identifiers in this representation are pre-translated, and the structure is traversed dynamically as needed during execution. This is the approach used by an interpreter for the language. A second approach is to use a compiler for the language. The compiler translates the program into the very low-level language native to the machine, appropriately called machine language. The native machine language acts as a least-common-denominator language for the computer.
    [Show full text]
  • Programming Fundamentals - I Basic Concepts Fall-Semester 2016
    Programming Fundamentals - I Basic Concepts Fall-Semester 2016 Prepared By: Rao Muhammad Umer Lecturer, Web: raoumer.github.io Department of Computer Science & IT, The University of Lahore. What is computer? The term "computer" was originally given to humans who performed numerical calculations using mechanical calculators, such as the abacus and slide rule. The term was later given to a mechanical device as they began replacing the human computers. Today's computers are electronic devices that accept data such as numbers, text, sound, image, animations, video, etc., (input), process that data (converts data to information) , produce output, and then store (storage) the results. A basic computer consists of 4 components: 1. Input devices 2. Central Processing Unit or CPU 3. Output devices 4. Memory Input Devices are used to provide input to the computer basic input devices include keyboard, mouse, touch screens etc. Central Processing Unit acts like a brain, it processes all instructions and data in the computer, the instructions are computer commands, these commands are given to CPU by input devices, some of the instructions are generated by the computer itself Output devices are used to receive computer output, the output, some basic output devices are hard drive disk (HDD, commonly known as hard disk), printers, computer screens (Monitors and LCDs) The computer memory is a temporary storage area. It holds the data and instructions that the Central Processing Unit (CPU) needs. Before a program can be run, the program is loaded from some storage device such as into the memory, the CPU loads the program or part of the program from the memory and executes it.
    [Show full text]
  • Introduction to Computer Programming
    Introduction to Computer Programming CISC1600/1610 Computer Science I/Lab Spring 2016 CISC1600 Yanjun Li 1 Outline This Course Computer Programming Spring 2016 CISC1600 Yanjun Li 2 1 This is a course In Programming For beginners who want to become professionals or who would like to know something about programming who are assumed to be bright Though not (necessarily) geniuses who are willing to work hard Though do need sleep occasionally, and take a normal course load Using the C++ programming language Spring 2016 CISC1600 Yanjun Li 3 Learning Goals Learn Fundamental programming concepts Key useful techniques Basic Standard C++ facilities After the course, you’ll be able to Write small sound C++ programs Read much larger programs Learn the basics of many other languages by yourself Proceed with an “advanced” C++ programming course After the course, you will not (yet) be An expert programmer A C++ language expert An expert user of advanced libraries Spring 2016 CISC1600 Yanjun Li 4 2 The Means Lectures Attend every one Outside of lectures Read a chapter ahead, and read the chapter again after each lecture Read actively: with questions in mind, try to reorganize/rephrase the key points in your mind Review questions/Terms in chapters Drills Always do the drills, before the exercises Exercises Spring 2016 CISC1600 Yanjun Li 5 The Means (Cont.) Lab projects That’s where the most fun and the best learning takes place Don’t wait until lab section to start the project Start to think about the project early Finish up & get help during labs Exams Midterms Final Spring 2016 CISC1600 Yanjun Li 6 3 How to be Successful? Don’t study alone when you don’t have to Form study groups Do help each other (without plagiarizing) If in doubt if a collaboration is legitimate: ask! Don’t claim to have written code that you copied from others Don’t give anyone else your code (to hand in for a grade) When you rely on the work of others, explicitly list all of your sources – i.e.
    [Show full text]
  • Lecture 1: Introduction to Java®
    Lecture 1: Introduction to Java MIT-AITI Kenya 2005 1 Lecture Outline • What a computer program is • How to write a computer program • The disadvantages and advantages of using Java • How a program that you write in Java is changed into a form that your computer can understand • Sample Java code and comments MIT-Africa Internet Technology Initiative ©2005 2 Computer Program vs. Food Recipe Food Recipe Computer Program A chef writes a set of A programmer writes a set of instructions called a recipe instructions called a program The recipe requires specific The program requires specific ingredients inputs The cook follows the The computer follows the instructions step-by-step instructions step-by-step The food will vary depending on The output will vary depending the amount of ingredients and on the values of the inputs and the cook the computer MIT-Africa Internet Technology Initiative ©2005 3 Recipe and Program Examples Student’s Student’s Ingredient # 1 Ingredient # 2 Name Grade Recipe Program Dinner “Bilha got an A on the exam!” MIT-Africa Internet Technology Initiative ©2005 4 What is a computer program? • For a computer to be able to perform specific tasks (i.e. print what grade a student got on an exam), it must be given instructions to do the task • The set of instructions that tells the computer to perform specific tasks is known as a computer program MIT-Africa Internet Technology Initiative ©2005 5 Writing Computer Programs • We write computer programs (i.e. a set of instructions) in programming languages such as C, Pascal, and
    [Show full text]
  • Learn Objective–C on The
    CYAN YELLOW SPOT MATTE MAGENTA BLACK PANTONE 123 C BOOKS FOR PROFESSIONALS BY PROFESSIONALS® Companion eBook Available Learn Objective-CLearn • Learn the native programming language for Mac OS X, Everything You Need to Know as well as the iPhone! to Become an Objective-C Guru • Get up and running quickly with Objective-C. We don’t waste time teaching you basic programming; instead, we focus on what makes Objective-C di!erent and cool. • Learn about sophisticated programming concepts, including object-oriented programming, the Open-Closed Principle, refactoring, key-value coding, and predicates. n this book, you’ll !nd a full exploration of the Objective-C programming Ilanguage, the primary language for creating Mac OS X and iPhone applica- tions. There are goodies here for everyone, whether you’re just starting out as a Mac developer or a grizzled programmer coming from another language. You’ll discover all of the object-oriented purity and Smalltalk heritage coolness of Objective-C—such as instantiation, protocols for multiple inheritance, dynamic typing, and message forwarding. Along the way, you’ll meet Xcode, the Mac development environment, and you’ll learn about Apple’s Cocoa toolkit. on the Nearly everyone wants to be able to develop for Mac OS X or the iPhone these days, and it’s no wonder. The Mac is a fun and powerful platform, and Objective-C is a wonderful language for writing code. You can have a great time programming the Mac in Objective-C. We do, and want you to join us! Mark Dalrymple is a longtime Mac and Unix programmer who has Mac code running all over the world.
    [Show full text]
  • What Is a Computer Program? 1 High-Level Vs Low-Level Languages
    What Is A Computer Program? Scientific Computing Fall, 2019 Paul Gribble 1 High-level vs low-level languages1 2 Interpreted vs compiled languages3 What is a computer program? What is code? What is a computer language? A computer program is simply a series of instructions that the computer executes, one after the other. An instruction is a single command. A program is a series of instructions. Code is another way of referring to a single instruction or a series of instructions (a program). 1 High-level vs low-level languages The CPU (central processing unit) chip(s) that sit on the motherboard of your computer is the piece of hardware that actually executes instructions. A CPU only understands a relatively low-level language called machine code. Often machine code is generated automatically by translating code written in assembly language, which is a low-level programming language that has a relatively direcy relationship to machine code (but is more readable by a human). A utility program called an assembler is what translates assembly language code into machine code. In this course we will be learning how to program in MATLAB, which is a high-level programming language. The “high-level” refers to the fact that the language has a strong abstraction from the details of the computer (the details of the machine code). A “strong abstraction” means that one can operate using high-level instructions without having to worry about the low-level details of carrying out those instructions. An analogy is motor skill learning. A high-level language for human action might be drive your car to the grocery store and buy apples.
    [Show full text]