CS307 Test #1

Card Set Information

Author:
rinyu
ID:
103248
Filename:
CS307 Test #1
Updated:
2011-09-21 01:17:47
Tags:
CS307 Test
Folders:

Description:
Definitions for CS307 Test #1
Show Answers:

Home > Flashcards > Print Preview

The flashcards below were created by user rinyu on FreezingBlue Flashcards. What would you like to do?


  1. A concept, thought, or idea apart from any particular instances or material objects. In computer science an organization of data, a manipulation of data, an algorithm, etc. apart from any particular programming language implementation of that thing.
    Abstract
  2. A data type whose properties (domain and operations) are specified independently of any particular implementation. Examples: List, Stack, Queue, Tree, Graph, Set.
    Abstract Data Type
  3. Formation of an idea, such as the qualities or properties of a thing, separate from any particular instances of a thing or material object. In computer science, a model of a complex system that includes only the details essential to the perspective of the viewer of the system.
    Abstraction
  4. an outline of the procedure for solving a problem. This includes (1) the actions which are to be taken, and (2) the order in which the actions are to be performed.
    Algorithm
  5. How you plan to solve the problem. This includes: (1) identifying the problem�s imputs, desired outputs, and other constraints, (2) specifying the form of the data input (units, format, order, and arrangement), and (3) specifying the form of data output.
    Analysis
  6. A measure of the amount of resources necessary to execute a section of code. The efficiency or running time of an algorithm stated as a function relating the input size/length to the number of steps (time complexity) or storage locations (space complexity).
    Analysis of Algorithms
  7. used to indicate the flow of control in the program.
    Arrows
  8. A function calling method in which the address or reference to the actual arguments are passed to a function. In C Call By Reference can be achieved by passing the addresses of variables or the values stored in pointers. In C++ functions can be defined that are Call By Reference functions. See the page on pointers for details on how to define a Call By Reference function. See also Call By Value.
    Call By Reference
  9. A function calling method in which only copies of the values stored in arguments to the function are passed into the function. All functions in C are Call By Value functions. See Call By Reference.
    Call By Value
  10. A structured type in a programming language containing variables and the functions which operate on those variables. Used to represent an abstract data type. See Object Oriented Programming.
    Class
  11. If an object already exists (perhaps written by another software developer), you can use that object in your program. This allows specialists to implement, test, and debug complex, task-specific objects, which you can then trust to run in your own code.
    Code Re-use*
  12. A method for handling collisions in a hash table, e.g. open addressing with linear probing, open addressing with double hashing, chaining, and buckets.
    Collision Resolution Techniques
  13. Functions that create an abstract data type. Examples: int X or new node(). Also the "constructor" function(s) in a C++ class.
    Constructors
  14. The separation of a data type's logical properties from its' implementation. Another term for Data Encapsulation.
    Data Abstraction
  15. The separation of the representation of data from the applications that use the data at a logical level. A programming language feature that enhances information hiding. Another term for Data Abstraction. See Information Hiding.
    Data Encapsulation
  16. An object expresses its behavior through methods (functions in some programming languages). Methods operate on an object's internal state and serve as the primary mechanism for object-to-object communication. Hiding the internal state and requiring all interaction to be performed through an object's methods is known as data encapsulation which is a fundamental principle of object-oriented programming.
    Defined behaviors*
  17. Only an object's methods should be able to modify its' state, i.e. none of the fields should be directly modifiable by other object's code.
    Defined ways of modifying the state*
  18. When an object needs to perform a certain task, but instead of doing that task directly it "asks" another object to handle the task, or sometimes just part of the task.
    Delagation*
  19. Develope the Algorithm, a list of steps to be taken to solve the problem.
    Design
  20. used to indicate decisions (like the if statement).
    Diamonds
  21. Allocating memory for a variable, structure, or class instance after a program has started running using either Malloc() (Standard C) or new (C++). See Static Memory Allocation.
    Dynamic Memory Allocation
  22. Hides the inner workings of your application's parts. Is about breaking your application into logical parts and then keeping those parts separate.
    Encapsulation*
  23. A specifier used to specify access to a global variable in one source file when the actual global variable is defined in another source file. A technique that is used more in old style procedural programming in C. Rarely if ever used in object oriented programming in C++.
    Extern
  24. A function, not part of a class, but which has been given access to all its' private member variables and functions.
    Friend Function*
  25. The ability to have two or more functions in a class with the same name but different number and/or types of arguments. The OS determines from the arguments in a call to one of the functions which one to execute.
    Function Overloading
  26. Code the algorithm in C.
    Implementation
  27. The second file needed to define a class. It contains all of the functions that are members of that class.
    Implementation File*
  28. The practice of hiding the details of a function, class, or data structure with the goal of controlling access to the details of the implementation of a class or structure. See Data Encapsulation.
    Information Hiding
  29. A mechanism by which one class acquires the properties (member variables and member functions) of another class.
    Inheritance
  30. (noun) The object that is created during the process of Instantiation (v). An instance of a class.
    Instantiation
  31. (verb) The process of dynamically allocating memory for an object. When a class object is dynamically allocated it has been instantiated.
    Instantiation
  32. The header file, one of the two files needed to define a class. Contains the definition of the class, using a syntax similar to that for defining a data structure.
    Interface File*
  33. Functions that perform some sequential action on all data components in an object, example: setAll(someValue);
    Iterators
  34. When the objects in an application each have a specific job to do and they do only that job. The functionality of the application is spread out over lots of well-defined objects.
    Loose Coupling*
  35. In C++ classes you can assign to the variables and functions an access scope using: public, private, and protected.
    Member Access Specifiers*
  36. All of the functions declared within a class definition.
    Member functions
  37. All of the variables declared within a class or structure definition.
    Member variables
  38. A system that allows a software designer to graphically layout and model a software application. It gives designers a way to literally draw a map of how a piece of software will be constructed and function.
    Modeling Language*
  39. The organization of a program into logical units. An important characteristic of well designed programs. The use of classes in C++ helps to enforce this.
    Modularity
  40. Value of bundling programs into objects.
    Modularity, Information-hiding, code re-use, and pluggability and debugging ease
  41. A unit of organization of a software system. In most cases a module is a single source code file containing a number of functions designed to provide a set of related services. Classes in C++ can be referred to as modules. A conceptual idea not necessarily a programming unit.
    Module
  42. A class can have more than one superclass. Thus it inherits variables and functions from more than one class.
    Multiple Inheritance*
  43. A software "bundle", usually thought of as being a class or structure consisting of a set of variables which define the states the object can exist in and a set of functions that define the behavior of that object. Software objects are often used to model the real-world objects that you find in everyday life.
    Object
  44. The process of identifying classes of objects and their interrelationships that are needed to solve a software problem.
    Object Oriented Design
  45. The use of data abstraction, inheritance and dynamic binding (memory allocation) to construct programs that are collections of interacting objects. The process of using objects as the building blocks of a program. See Procedural Programming, Top Down Design, Bottom Up Design.
    Object Oriented Programming
  46. Functions that observe the state of one or more data values. This includes (1) Predicates--checks to see if a certain property is true or false, example: isEmpty(), (2) Accessor or Selector--returns a copy of a data object, example: getX(), (3) Summary--returns information about an object as a whole, example: getListLength().
    Observers
  47. All the functions that act on a domain of data. Example: for the int data type the operations include +, -, *, /, %, &, |, etc. See Abstract Data Type.
    Operations
  48. A specific case of polymorphism, where different operators have different implementations depending on their arguments.
    Operator Overloading*
  49. If a particular object turns out to be problematic, you can simply remove it from your application and plug in a different object as its replacement. This is analogous to fixing mechanical problems in the real world. If a bolt breaks, you replace it, not the entire machine. And you don�t have to retest the entire machine functionality just because you replaced a bolt. (Imagine the absurdity of having to have every mechanical and electrical system of your car retested to make sure it functions correctly every time you replaced the tires.)
    Pluggability and Debugging
  50. A variable whose value is the address in memory of another variable. Pointers are typed. Thus you have int pointers that hold the address of int variables, float pointers that hold the address of float variables, etc. See the page on pointers for details on how to declare and use pointers.
    Pointer
  51. The ability of different sub-classes of a parent class to inherit functions from the parent class yet implement the functions in very different ways.
    Polymorphism
  52. Variables and functions in a structure or class which can only be accessed from within the object. Default state for member variables of classes.
    Private
  53. Program design focusing on which functions are part of a program and how the functions interact to accomplish the goals of the program. See Object Oriented Programming, Top Down Design, Bottom Up Design.
    Procedural Programming
  54. Variables and functions in a structure or class which may be accessed only from other functions within the class or from functions in objects that are sub-classes of the class.
    Protected
  55. An artificial and informal way of describing an algorithm. NOTE: There is no formal syntax or structure known as pseudocode. It is just a plain English outline of a program. The advantage is it allows you to concentrate on HOW to solve a problem without worrying about the programming language syntax at the same time.
    Pseudocode
  56. Variables and functions in a structure or class which are global and may be accessed from anywhere if there is access to the object. Default state for member variables of structures.
    Public
  57. Translating the customer's description of the desired software system into a list of requirements. Determine exactly what the software should do.
    Requirement Analysis*
  58. An expression of desired behavior for a software system, i.e. a statement of something it must do.
    Requirements
  59. The document, which is prepared from the Statement of Work and presented to the customer. It's primary purpose is to varify with the customer the exact scope of requirements for a piece of software. The RDD is created during the Requirements Specification phase of software engineering.
    Requirements Definition Document or Requirements Description Document (RDD)
  60. A detailed list of what the program must be able to do. In large development projects this is usually referred to as the Statement of Work.
    Requirements Specification
  61. The section of code in which a variable can be accessed. For example, any variable defined inside of a function has scope only within the function. It cannot be accessed from outside the function.
    Scope
  62. used to indicate the entry and exit points to a block of code.
    Small Circles
  63. The document which describes in detail each module of a software system, each function within the module, the function inputs and outputs, and the algorithms each function will perform. The SDD or SDP contains a description of the interface between each module and the interface with the user. The SDD or SDP is created during the Design phase of software engineering.
    Software Design Document (SDD) or Software Development Plan (SDP)
  64. A disciplined approach to the design, production, and maintenance of computer programs that are developed on time and within cost estimates, using tools to help manage the size and complexity of the resulting software products.
    Software Engineering
  65. The document which presents a thorough analysis of the requirements of a piece of software. The SRS is based on the SOW and RDD and is written in terms the software designers and programmers can use. The SRS is created during the Analysis phase of software engineering.
    Software Requirements Specification (SRS)
  66. A detailed description of the functions, inputs, processing, outputs, and special requirements of a software product. This provides the information needed to design and implement the program.
    Software Specification
  67. The document which is a detailed, organized plan for testing a piece of software. The STP includes a description of all tests to be performed, the procedure for performing the test, the inputs for the test, and the expected outputs. The STP is created during the Testing phase of software engineering, but the normal approach is to begin working on a rough draft of the STP during the design phase so that every part of the system included in the design has a test or tests included in the STP.
    Software Test Plan (STP)
  68. An object stores its state in fields, i.e. member variables in classes.
    State*
  69. The document, usually received from a customer, that states specifically the customer's requirements for a software product. The SOW is created during the Requirements Specification phase of software engineering.
    Statement Of Work
  70. A function in a class definition (.h) file declared as static (ex: static someFunction() is declared in MyClass.h) can be called without having to create an instance of the class. For example: MyClass::someFunction() would call the static function as defined above. However, if there are multiple instances of the class all will share the same instance of the static function and static functions cannot access non-static variables or functions in a class.
    Static
  71. A global variable declared as static in a source code file cannot be declared as extern in another source file and accessed.
    Static
  72. A variable defined as static inside of a function (ex: static int x = 0;) maintains the same value it had the last time the function was called. In the example given the first time the function containing x is called the variable is created and initialized to the value of zero. If while the function is running x is incremented with x++; then the next time the function is called x will have the initial value of one.
    Static
  73. An access specifier which has a several uses.
    Static
  74. The process in software design of starting off at a high level of abstraction and working down through an interative process to add more and more detail to the design.
    Step-wise Refinement
  75. Functions that change the data in some way. Examples: X=3. The "equals" function set the value to store in the variable X. This may include setting values, inserting or deleting an item from an object, or combining two objects.
    Transformers
  76. This is a two step process. It involves (1) determining if the program does, in fact, produce results that satisfy the original requirements (Verification), and (2) the results are accurate (Validation).
    Verification and Testing

What would you like to do?

Home > Flashcards > Print Preview