Back to FAQ
[USA] [NON-USA]
In order by state.
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
University of Alaska - Fairbanks |
|
Objective: Teach Ada language, syntax, objects, object-oriented programming, and Ada features. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: 486 PCs Compiler: Meridian Textbook: Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Optional)
Alabama A&M University
|
|
Objective: Broad introduction to programming methodology using Ada, with emphasis on techniques to develop computer applications, including data abstraction, information hiding, and data packages. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM PS/2 Model 70, Version 2.1.1 Compiler: Janus, Meridian, TeleSoft Textbook: Volper, Dennis, and Martin D. Katz. Introduction to Programming Using Ada. Prentice-Hall, 1989. 576p. (ISBN: 0-685-27168-4; $30.00/paper) (Required), Winters, John. Power Programming With Ada for the IBM PC. TAB Books, 1987. 207p. (ISBN: 0-8306-2902-5; $16.95/paper) (ISBN 0-8306-7902-2DP 1987; $24.95/trade) (Optional)
Alabama State University |
|
Objective: Continuation of CSE 200; pointers and dynamic data structures; linked lists, stacks, trees, and graphs. Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Sparc Workstations Compiler: Sun Ada/Verdix Ada (VADS) Tool: VADS, GRASP/Ada Textbook: Naps. Introduction to Computer Science: Programming, Problem Solving and Data Structures. West Publishing, 1992. (Required), Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Optional)
Auburn University
|
|
Objective: Broad introduction to programming methodologies; abstraction, decomposition, modularity. Concept: Abstract Data Types, Design Concepts, Packages, Problem Solving, Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Sparc Workstations Compiler: Sun Ada/Verdix Ada (VADS) Tool: VADS, GRASP/Ada Textbook: Delillo, Nicholas J. A First Course in Computer Science with Ada. Irwin, 1993. (ISBN: 0-256-12538-4) (Required), Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Optional)
Auburn University
|
|
Objective: Tools and methodology for design and implementation of complex software systems. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Sun Sparc Workstations Compiler: Rational Apex Tool: Rational Rose Ada, Testmate, GRASP/Ada Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required), Ada95 Language Reference Manual (Optional), Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Optional)
Auburn University
|
|
Objective: Design of reliable systems; correctness verification; software testing; testing tools. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Sun Sparc Workstations Compiler: Rational Apex Tool: Rational Rose Ada, Testmate, GRASP/Ada Textbook: Pressman, Roger. Software Engineering: A Practitioner's Approach. McGraw-Hill, 3rd ed., 1991 (Required), Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Optional)
Auburn University
|
|
Objective: Object-oriented design with Ada 95 Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Domain Analysis, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: Sun Sparc (Solaris) Compiler: Rational Apex 2.0, GNAT Tool: Rose/Ada, Jest Mate, GRASP/Ada Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required)
Auburn University
|
|
Objective: To study several programming languages other than the students' primary language, and learn to write intermediate-level computer programs in each. Concept: Abstract Data Types, Exception Handling, Generics, Multi-tasking, Packages, Tasking Audience: Student Background: Student (attending college/university) Computer: HP 9000 as host with LAN Ethernet connecting PCs Compiler: ICC Textbook: Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Required)
Birmingham Southern College
|
|
Objective: An introduction to the principles of software design and development using the Ada programming environment. Concept: Ada 95 Compatible Issue, Design Concepts, Software Development Process, Software Engineering, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Jacksonville State University |
|
Objective: Provide a study of the Ada language and its use in large-scale and embedded-software development. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: IBM PC XT & AT Compiler: Meridian Textbook: Watt, David A., et al. Ada Language and Methodology. Prentice-Hall, 1987. 515p. (ISBN: 0-13-004078-9; $39.50) (Required)
Southeastern Institute of Technology
|
|
Objective: Familiarizes students with the concepts and constructs of a high-level, strongly-typed language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: IBM 486 DX2, 66MHZ Compiler: GNU NYU Ada Textbook: Pratt. Programming Languages. 1984., Kernighan & Ritchie. The C Programming Language. 1988 (Required)
Troy State University at Dothan
|
|
Objective: The primary focus of this course is to introduce the students to various topics related to Ada 95 with an emphasis on object-oriented modeling and design. Concept: Design Concepts, Object-oriented Design, Packages Audience: Student Background: Student (attending college/university) Textbook: Rendezvous with Ada 95 by David Naiditch. (Required)
University of Alabama - Tuscaloosa
|
|
Objective: Study programming-language concepts, organization, paradigms, design issues. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: IBM RS/6000; IBM PCs Compiler: IBM RS/6000 Ada Compiler Textbook: Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Required)
University of Alabama - Tuscaloosa |
|
Objective: Introduced students to both C++ and Ada programming. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
University of Alabama - Tuscaloosa
|
|
Objective: Introduction to the fundamentals of programming and program structure and the basic concepts of data structures and algorithm design using the Ada programming language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: 486 PC Compiler: IntegrAda 4.3, Dec Ada Tool: Some graphics tools come with IntegrAda and instructor furnished packages. Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Southern Arkansas University
|
|
Objective: Follow up to Ada Programming I. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: 486 PC Compiler: IntegrAda 4.3, Dec Ada Tool: Some graphics tools come with IntegrAda and instructor furnished packages. Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Southern Arkansas University
|
|
Objective: To teach fundamental software tools in Ada, including stepwise refinement, segmentation, iterative enhancement, organization, and management of large software projects. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Packages, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Macintosh Compiler: Open Ada Mac Meridian (Verdix) Tool: AdaFlow Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
University of Arkansas
|
|
Objective: A beginning course in the Ada programming language. Topics will include syntax and semantics, data types, operators, looping and decision structures, function, procedures, packages, exception handling and file handling. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Manager/Administrator, Other Background, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: PCs Compiler: Meridian Ada Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Cochise College |
|
Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Janus Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Embry - Riddle Aeronautical University |
|
Objective: Introduction to file and database systems, including file processing, data structures and algorithms. Concept: Design Concepts, Packages, Problem Solving, Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: R & R Janus Ada Tool: AdaVision
Embry - Riddle Aeronautical University
|
|
Objective: Study of basic techniques of computer graphics with primary emphasis on learning how to develop a device independent computer graphics packages using Ada. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Janus
Embry - Riddle Aeronautical University
|
|
Objective: Introduction to problem-solving methods and algorithm. Design, code, implement and test programs written in Ada. Concept: Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Janus Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Embry - Riddle Aeronautical University |
|
Objective: Emphasizes program design, style, information hiding, data abstraction, reusability, debugging, and testing, especially for larger programs. Introduction to algorithm analysis, introduction to basic aspects of files, input/output, string processing, recursion. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Janus Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Embry - Riddle Aeronautical University |
|
Objective: Introduction to Ada language for non-computer science students. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Packages, Problem Solving, Real-time Programming, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: R & R Janus Ada
Embry - Riddle Aeronautical University
|
|
Concept: Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Janus Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Embry - Riddle Aeronautical University |
|
Objective: Learn how to program with Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: Sun Workstations Compiler: DDCI Ada Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Weiss, Mark. Data Structures & Algorithm Analysis in Ada. Benjamin-Cummings, 1993. (ISBN: 0-805-39055-3; $51.75) (Required)
Northern Arizona University
|
|
Objective: Teaches students how to model reactive systems, especially by using Ada tasks and the "entity-life approach of Bo Sanden. Also teches Ada 95 to students who know Ada 83. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Domain Analysis, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: GNAT Textbook: Sanden, B. Software Systems Construction with Examples in Ada. Prentice-Hall, 1994. (ISBN: 0-13-030834-X; $44.39) (Required), Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Optional)
Northern Arizona University
|
|
Objective: Advanced programming techniques, including data-structure definition, design, and implementation. Topics include recursion, dynamic structures, sorting and searching techniques. Algorithmic development and modularity are emphasized. Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: MacIntosh Compiler: Meridian Ada on Macintosh, GWAda
Allan Hancock College
|
|
Objective: Provide a beginning programming course for computer-science majors. Concept: Design Concepts, Problem Solving Audience: Student Background: Computer Scientist Computer: Macintosh Compiler: Meridian Ada Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Allan Hancock College
|
|
Objective: Introduce students to abstract data types implemented as reusable generic packages. Introduce advanced programming techniques and basic algorithms. Concept: Abstract Data Types, Exception Handling, Generics, Object-oriented Design, Packages, Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: VAX 8000, IBM PC Compiler: VAX Ada, Meridian Ada Textbook: Hillam, Bruce P. Introduction to Abstract Data Types using Ada. Prentice-Hall. (ISBN: 0-13-079096-6). Uses Ada's generic package mechanism to teach abstract data types. Text is designed to be the primary text for an Ada based CS2 text. Instructor's manual contains disk with software designed to validate various student projects. (Required)
California State Polytechnic University at Pomona
|
|
Objective: Introduce students to abstract data types implemented as reusable generic packages. Introduce advanced programming techniques and basic algorithms. Concept: Abstract Data Types, Exception Handling, Generics, Object-oriented Design, Packages, Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: VAX 8000, IBM PC Compiler: VAX Ada, Meridian Ada Textbook: Hillam, Bruce P. Introduction to Abstract Data Types using Ada. Prentice-Hall. (ISBN: 0-13-079096-6). Uses Ada's generic package mechanism to teach abstract data types. Text is designed to be the primary text for an Ada based CS2 text. Instructor's manual contains disk with software designed to validate various student projects. (Required)
California State Polytechnic University at Pomona
|
|
Objective: Theory and application of various data structures as the foundation of computer science. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Packages, Problem Solving, Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Compiler: Meridian Ada Textbook: Hillam, Bruce P. Introduction to Abstract Data Types using Ada. Prentice-Hall. (ISBN: 0-13-079096-6). Uses Ada's generic package mechanism to teach abstract data types. Text is designed to be the primary text for an Ada based CS2 text. Instructor's manual contains disk with software designed to validate various student projects. (Required)
California State Polytechnic University at Pomona
|
|
Objective: Introduce new students to the concepts of computer science and the discipline of programming using the Ada language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Packages, Problem Solving, Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: VAX 8000 Compiler: VAX/VMS Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
California State Polytechnic University at Pomona
|
|
Objective: Introduce new students to the concepts of computer science and the discipline of programming using the Ada language. Concept: Abstract Data Types, Design Concepts, Packages, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: VAX 8000, IBM PC Compiler: VAX Ada, Meridian Ada Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
California State Polytechnic University at Pomona
|
|
Objective: Introduce new students to the concepts of software engineering, group projects, reliability, and validation. Concept: Design Concepts, Software Engineering Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: Rational Ada Textbook: Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required)
California State Polytechnic University at Pomona
|
|
Objective: Introduce new students to the concepts of software engineering, group projects, reliability, and validation. Concept: Design Concepts, Software Engineering Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: Rational Ada Textbook: Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required)
California State Polytechnic University at Pomona
|
|
Objective: Teach real-time and concurrent processing issues. Concept: Object-oriented Design, Real-time Programming, Software Engineering, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: RS6000, Hewlett-Packard 9000/400, Sun 690MP Compiler: Meridian Ada, Alsys Ada on RS6000
California State Polytechnic University at San Luis Obispo
|
|
Objective: Teach intermediate data structures. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: RS6000, Sun 690MP, Macintosh PCs, Hewlett-Packard 9000/400 Compiler: Meridian Ada, Alsys Ada on RS6000 Textbook: Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Required), Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Required)
California State Polytechnic University at San Luis Obispo
|
|
Objective: Teach file structures. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: RS6000, Hewlett-Packard 9000/400, Sun 690MP, Macintosh Compiler: Meridian Ada, Alsys Ada on RS6000 Textbook: Miller, Nancy E., and Charles G. Peterson. File Structures With Ada. Benjamin-Cummings, 1990. (ISBN-8053-0440-1; $39.95/text) (Required)
California State Polytechnic University at San Luis Obispo
|
|
Objective: CS1 & CS2 equivalent Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: IBM RS 6000, IBM Compatibles Compiler: OC Systems on RS 6000, GW Ada, Meridian, Open Ada 386 for DOS Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required), Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Optional)
California State Polytechnic University at San Luis Obispo
|
|
Objective: Study full software-engineering lifecycle. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: RS6000, Hewlett-Packard 9000/400, Sun 690MP, Macintosh Compiler: Meridian Ada, Alsys Ada on RS6000
California State Polytechnic University at San Luis Obispo
|
|
Objective: Study full software-engineering lifecycle. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: RS6000, Hewlett-Packard 9000/400, Sun 690MP, Macintosh Compiler: Meridian Ada, Alsys Ada on RS6000
California State Polytechnic University at San Luis Obispo
|
|
Objective: Learn how to write programs in Ada. Concept of package and generic, concept of modularity and data abstraction. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: VAX Compiler: VAX Ada
California State University - Bakersfield
|
|
Objective: Provide a fast introduction to Ada for Pascal students. Concept: Abstract Data Types, Packages, Tasking Audience: Student Background: Computer Scientist Computer: VAX Compiler: Meridian Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
California State University - Fullerton
|
|
Objective: Examination of Ada advanced features, software lifecycles, and functional decomposition. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: VAX, PCs Compiler: Meridian, DEC
California State University - Long Beach |
|
Objective: Teach introductory programming using Ada. Concept: Abstract Data Types, Design Concepts, Problem Solving, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: VAX, PCs Compiler: Meridian, DEC Textbook: Volper, Dennis, and Martin D. Katz. Introduction to Programming Using Ada. Prentice-Hall, 1990. 650p. (ISBN: 0-13-493529-2; $30.00) (Required)
California State University - Long Beach |
|
Objective: Teach programming using Ada. Concept: Abstract Data Types, Design Concepts, Problem Solving, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: VAX, PCs Compiler: Meridian, DEC Textbook: Volper, Dennis, and Martin D. Katz. Introduction to Programming Using Ada. Prentice-Hall, 1990. 650p. (ISBN: 0-13-493529-2; $30.00) (Required)
California State University - Long Beach |
|
Objective: Application of Ada for implementing large systems with emphasis on quality factors - Reliability, Maintainability and Portability. Development of concurrent control software for embedded/real-time systems. Course is being updated to cover Ada 95. textbook has not been decided yet. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Real-time Programming, Reuse Unlisted Concept(s), Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: HP 9000 series, workstations networked to central server. Compiler: Rational Ada
California State University - Northridge |
|
Objective: Provide introduction to techniques in software design, development, and verification. Team projects where students work on a large software project. Concept: Design Concepts, Packages, Software Development Process, Software Engineering, Tasking Audience: Student Background: Computer Scientist Computer: IBM 80486 Compiler: Meridian Ada Textbook: Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required)
California State University - Stanislaus
|
|
Objective: To train students in the grammar and syntax of the Ada programming language. To show the basics of Ada's object-oriented capabilities and reusable code. Concept: Design Concepts, Generics, Object-oriented Design, Problem Solving, Reuse Unlisted Concept(s), Software Development Process Audience: Other Audience, Student Background: Student (attending college/university) Computer: IBM Clone 386 DX 33 with 8 MB RAM
Chabot Community College |
|
Objective: An entry level course in Ada. Covers data types, control structures, strings, arrays, procedures, functions, I/O, and exception handling. Concept: Design Concepts, Exception Handling, Problem Solving, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university), System Analyst Computer: MS-DOS Compatibles Compiler: Aetech, IntegraAda Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
College of the Canyons
|
|
Objective: Teach the techniques of problem analysis and solution using the Ada programming language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: 386-based PC Clones Compiler: OpenAda Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
Cuesta College
|
|
Objective: This is an introductory course in basic principles and operation of digital computers. It includes binary and hexadecimal arithmetic, Boolean algebra, computer logic, problem solving methodology, computer programming in Ada and program documentation. Elementary numerical techniques are used for problem solving. Concept: Design Concepts, Problem Solving, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Cypress College |
|
Objective: This course includes problem solving methodology with the development and application of data structures, including records, multidimensional arrays, stacks, queues, linked lists, trees, sorting methods, and recursion using Ada. Concept: Design Concepts, Problem Solving, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Cypress College |
|
Objective: Designed to meet the requirements of beginning data structure oo courses taught in the computer science curriculum at the univeristy level. This is not a course in Ada programming. The Ada language is the only programing language of choice to teach the class. Some of the topics covered will be queues and stacks, linked lists, directed graphs, tree structures, and sorting methods. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Maridian Open Ada version 4.1.4 Textbook: Hillam, Bruce P. Introduction to Abstract Data Types using Ada. Prentice-Hall. (ISBN: 0-13-079096-6). Uses Ada's generic package mechanism to teach abstract data types. Text is designed to be the primary text for an Ada based CS2 text. Instructor's manual contains disk with software designed to validate various student projects. (Required)
Fullerton College
|
|
Objective: Covers all material necessary to be successful in developing well structured programs through step-wise algorithm development. Student is expected to: learn how to develop algorithms in Ada, develop Ada syntax competence, develop debugging competence and develop appropriate documentation skills. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: 486 Compiler: Meridian Open Ada version 4.1.4 Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Fullerton College
|
|
Objective: To present the cyntax of the Ada language - general programming habits, encapsulation, exception handling. Concept: Exception Handling, Generics, Packages, Problem Solving, Strong Typing Audience: Student Background: Student (attending college/university) Computer: MicroVAX II Compiler: VAX Ada Textbook: Smith, James. Introduction to Programming Concepts & Methods with Ada. McGraw-Hill, 1993. (ISBN: 0-007-05929-8; $31.96) (ISBN: 0-07-059209-8; $39.95/paper) (Required)
La Sierra University
|
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Loyola Marymount University |
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact Michael B. Feldman of George Washington University at mfeldman@seas.gwu.edu. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Monterey Peninsula College |
|
Objective: Continuation of Introduction to Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: 486 Compiler: Meridian Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
National University
|
|
Objective: Prepare for software engineering. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: 486 Compiler: Meridian Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
National University
|
|
Objective: Provide a survey of important functional and imperative programming-language concepts, emphasis in C, Ada, and Lisp. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Macintosh, VAX, Sun Compiler: Verdix Textbook: Appleby, Doris. Programming Languages: Paradigm & Practice - Ada Mini-Manual. McGraw-Hill, 1991. (ISBN: 0-07-002578-9) (Required)
Pepperdine University
|
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
San Diego Mesa College of the San Diego Community College District |
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Santa Clara University |
|
Objective: Course outline sites:Understanding Objects, Problem Statements, Modeling, Decomposition and Partitioning, Software Project Life-Cycles, OO Work Products Within the Project Life-Cycle, Threading the System, Interfaces, Management of OO, Reuse, Testing, The Transition to OO, Traceability, Metrics, Tools. Concept: Object-oriented Design, Reuse Unlisted Concept(s) Audience: General Public Background: Computer Scientist, Manager/Administrator, Software Engineer/Developer
University of California - Berkley Extension
|
|
Objective: Organization of programming languages, virtual machines, translation from high-level to low-level languages, language extension mechanisms, Ada as an implementation language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: IBM-PC compatibles Compiler: Meridian Ada Textbook: Gonzalez, Dean W. Ada Programmer's Handbook. Benjamin-Cummings, 1991. (ISBN: 0-8053-2529-8; $13.95/paper) (Optional), Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Optional)
University of the Pacific |
|
Objective: Acquaints the student with the complex topics of software engineering using Ada as the programming tool. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: General Public, Student Background: Computer Scientist, Manager/Administrator, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: PCs/HP9000 Compiler: HP version of Ada compiler
Aims Community College
|
|
Objective: Compbine software engineering principles with knowledge of Ada. Teach a course in how to build CASE tools with Ada as the language, thus spreading use of Ada. Concept: Abstract Data Types, Design Concepts, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Software Development Process, Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: UNIX work stations. Compiler: Free Ada compiler. Textbook: Neilson. Usability Engineering. Academic Press, 1993. (Required), von Maythauser, A. Software Engineering Methods and Management. Academic Press, 1990. (Required)
Colorado State University
|
|
Objective: Ada covered for 1/3 of course. Provides students with the necessary tools for critically evaluating existing and future languages and language constructs. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Reuse Unlisted Concept(s), Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM PC compatibles, DEC Alphas Compiler: VAX Ada, GNAT Ada Textbook: Cohen, Norman C. Ada as a Second Language. McGraw-Hill, 1986. 838p. (ISBN: 0-07-011589-3; $36.04/paper) (Required), Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Required)
Fort Lewis College
|
|
Objective: Teach software engineering to students. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: 386 Compiler: Meridian Ada Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required)
University of Southern Colorado
|
|
Objective: Presents types, packages, concurrency, exceptions, and generic facilities, and stresses Ada as a vehicle for implementing software-engineering principles. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: VAX 9000/210 Compiler: Standard Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
Central Connecticut State University |
|
Objective: Teaches problem solving, software development and a high level language. Also provides an overview of computer science. Concept: Abstract Data Types, Design Concepts, Generics, Object-oriented Design, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Mac II, Macintosh, IBM PC, MICROVAX/UNIX Compiler: GNU Ada
Connecticut College
|
|
Objective: The objective of this course is to use some of the basic features of software engineering to support the development of high quality software using Ada. Basic software engineering principles can be indirectly learned during the first two programming courses, CS1 and CS2. Concept: Abstract Data Types, Design Concepts, Generics, Packages, Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: VT100 terminals and PCs networked to Dec 5500 Compiler: Dec Ada, GWU Ada Ed. Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Sacred Heart University
|
|
Objective: This course is designed to introduce students to programming habits in using a structured language and to develop good habits in writing structured programs using Ada and software-engineering concepts. Concept: Design Concepts, Exception Handling, Packages, Problem Solving, Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: DEC 5500 Compiler: DEC Ada Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required), "Software Engineering, A Programming Approach", Bell Morrey, Pugh Practice Hall. (Optional)
Sacred Heart University
|
|
Objective: To teach the syntax and semantics of all aspects of the Ada language. Concept: Abstract Data Types, Annexes, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: DEC Compiler: DEC Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required), Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Optional)
Three Rivers Community Technical College
|
|
Objective: Teach students the newest concepts in high-level languages, along with concurrent programming concepts. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Real-time Programming, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Vax, IBM Workstations Compiler: VAX Textbook: Booch, Grady. Object Oriented Design with Applications. Benjamin-Cummings, 1991. (ISBN: 0-8053-0091-2) (Required)
Three Rivers Community Technical College |
|
Objective: Presents principles of software engineering - traditional. Object-oriented emphasis added to reflect current paradigm. Focus on design and its important role in software engineering. Concept: Abstract Data Types, Design Concepts, Management Overview, Object-oriented Design, Reuse Unlisted Concept(s), Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: GNAT Ada 9X Textbook: Ghezzi. Fundamentals of Software Engineering. Prentice-Hall, 1991. (Required)
University of Connecticut
|
|
Objective: Offer a standard third-year computer-science course. Covers stacks, queries, trees. Concept: Abstract Data Types, Design Concepts, Object-oriented Design, Packages, Problem Solving, Software Engineering Audience: Student Background: Computer Scientist, Student (attending college/university) Compiler: VAX-Mainframe Textbook: Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Required)
Gallaudet University
|
|
Objective: Provide a graduate course in comparative programming languages. Ada is studied in the context of its interesting features such as packages, exception-handling, and tasking. Programming projects require coding in several languages, of which Ada is one. Concept: Abstract Data Types, Exception Handling, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: DOS, Mac labs; Sun Sparc 1000 Compiler: Ada/Ed-Unix, GW-Ada/Ed-Mac, GW-Ada/Ed-DOS, Alsys-Solaris, GNAT Textbook: Cohen, Norman C. Ada as a Second Language. McGraw-Hill, 1986. 838p. (ISBN: 0-07-011589-3; $36.04/paper) (Required)
George Washington University
|
|
Objective: Provide a study of comparative models of concurrency. The Ada tasking model is studied in depth, as are the concurrency of other models such as OCCAM and Concurrency C. Programming assignments require coding in several languages, of which Ada is one. Concept: Exception Handling, Packages, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: Sun Sparc 1000; DOS, Mac labs Compiler: Ada/Ed, GNAT, Alsys Textbook: Ben-Ari. Principles of Concurrent & Distributed Programming. Prentice-Hall, 1990. (Required), Gehani, Narain. Ada: Concurrent Programming. 2nd edition. Silicon, 1991. 230p. (ISBN: 0-929306-08-2; $30.95/trade) (Required)
George Washington University
|
|
Objective: Concentrates on classical sequential, random, and indexed files. Ada is used as the language of discourse in most of the course; projects are written first in Ada and later in C, for comparison. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Other Audience, Student Background: Student (attending college/university) Computer: Mac, DOS labs; Sun Sparc 1000 running Solaris Compiler: Ada/Ed-Unix, GW-Ada/Ed-DOS, GW-Ada/Ed-Mac, Alsys-Unix, GNAT Textbook: Miller, Nancy E., and Charles G. Peterson. File Structures With Ada. Benjamin-Cummings, 1990. (ISBN-8053-0440-1; $39.95/text) (Required)
George Washington University
|
|
Objective: Offer a non-credit, 5-day continuing-education seminar for students with some experience in the Ada language. The course emphasizes a number of topics including numerics, variant records, tasking, and machine-dependent programming. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: General Public Background: Computer Scientist, Software Engineer/Developer, System Analyst Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required)
George Washington University
|
|
Objective: Offer a 5-day seminar introducing the Ada programming language in a non-judgmental way. About half of time is hands-on programming workshops. Includes Ada 9X revisions. Available as in-house for government and industry. Concept: Abstract Data Types, Ada 95 Compatible Issue, Exception Handling, Generics, Packages, Software Engineering, Strong Typing, Tasking Audience: General Public Background: Computer Scientist, Manager/Administrator, Software Engineer/Developer, System Analyst Textbook: Naiditch, David. Rendezvous with Ada: A Programmer's Introduction. Wiley, 1989. 477p. (ISBN: 0-471-61654-0; $39,95/paper) (Required)
George Washington University
|
|
Objective: First-semester university course, intended for students with no prior programming experience. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Other Audience, Student Background: Student (attending college/university) Computer: Mac, DOS labs; Sun Sparc 1000 running Solaris Compiler: Ada/Ed-Unix, GW-Ada/Ed-DOS, GW-Ada/Ed-Mac, Alsys-Unix Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1992. 704p. Illustrated. (ISBN: 0-201-50006-X) (Required)
George Washington University
|
|
Objective: Concentrates on object-based programming, abstract data types, and generics, as well as on classical data structures such as stacks, queues, linked lists, graphs, trees, hash tables, etc. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Other Audience, Student Background: Student (attending college/university) Computer: Mac, DOS labs; Sun Sparc 1000 running Solaris Compiler: Ada/Ed-Unix, GW-Ada/Ed-DOS, GW-Ada/Ed-Mac, Alsys-Unix Textbook: Feldman, Michael B. Data Structures with Ada. Prentice-Hall (Reston Imprint), 1985. (ISBN: 0-8359-1220-5) Also Addison-Wesley, 1985. 313p. (ISBN: 0-201-52673-5; $47.50/text) (Required), Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1992. 704p. Illustrated. (ISBN: 0-201-50006-X) (Required)
George Washington University
|
|
Objective: Undergraduate and graduate versions of a first course in construction of compilers and other translators. Ada is used as the language of discourse; projects are written in Ada and C. Concept: Unlisted Lesson(s) Audience: Other Audience, Student Background: Student (attending college/university) Computer: Mac, DOS labs; Sun Sparc 1000 running Solaris Compiler: Ada/Ed-Unix, GW-Ada/Ed-DOS, GW-Ada/Ed-Mac, Alsys-Unix, GNAT Tool: Ayacc, Aflex Textbook: Fischer, C., and R. LeBlanc. Crafting a Compiler. Benjamin-Cummings, 1988. (Required)
George Washington University
|
|
Objective: Develops skills required to contribute in the implementation of a large software solution. The primary language stressed is Ada, although there are some C programming exercises. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university) Computer: PCs, DEC VAX, HP 9000 Compiler: NYU, DEC Ada, Verdix Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Howard University
|
|
Objective: Introduces students to the issues involved with systematic programs of software reuse. Concept: Domain Analysis, Reuse Software Certifying, Reuse Software Classifying, Reuse Software Developing, Reuse Software Legal Issues, Reuse Software Testing, Software Engineering Audience: Student Background: Student (attending college/university)
Howard University
|
|
Objective: This course focuses on all key competencies established for DAWIA Level III for software acquisition professionals and uses in-depth study of real and hypothetical software acquisition cases from within the DoD to include C41, AIS and MCCR. Students extend their knowledge, appropriate to Level III positions, about program planning and management for software acquisition, risk identification and mitigation, software acquisition critical success factors and best practicies, including management of a program management office. Concept: Domain Analysis, Reuse Business Value, Reuse Software Certifying, Reuse Software Classifying, Reuse Software Developing, Reuse Software Legal Issues, Reuse Software Testing Audience: Other Audience, Student Background: Manager/Administrator Computer: Lap-top 486 w/ CD-ROM and muilt-media provided Textbook: Davidson, J. The New Project Management. Frame. Jossey-Bass Publishers, San Francisco, 1994. (Required), Reifer, Donald. Software Management, 4th Edition. (Required)
Information Resource Management College
|
|
Objective: To present Ada to the students, and to get them to learn the basics in the programming of this language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Other Background, System Analyst Computer: Sun Compiler: Verdix
University of Delaware |
|
Objective: Teach students to scientifically participate in Ada programming laboratories. Support engineering rigor in software programming. Support object oriented programming and design. Lab manual and dikette used in classes. Concept: Design Concepts, Object-oriented Design, Software Engineering, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Florida A&M University
|
|
Objective: To teach students the Ada programming language. Stresses the use of good software-engineering techniques. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Multi-tasking, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Sun Workstations, IBM PCs Compiler: Meridian, Verdix, GNAT Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
Florida A&M University
|
|
Objective: Provide an introductory computer-science course using Ada. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: PCs and Sun Workstations Compiler: Meridian Open Ada, GNAT Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Florida Institute of Technology
|
|
Objective: Provide a second introductory computer-science course. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: PCs and Sun Workstations Compiler: Meridian Open Ada, GNAT Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Florida Institute of Technology
|
|
Objective: Provide a third introductory computer-science course. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: IBM-AT Clones Compiler: Meridian Open Ada Textbook: Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Required)
Florida Institute of Technology
|
|
Objective: Provide team-oriented projects to prepare students for large-scale systems development. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: IBM-PC Clones, Suns Compiler: Meridian Open Ada Tool: Rational Apex Textbook: Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Required)
Florida Institute of Technology
|
|
Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: VAX 8800 Compiler: VAX Ada Textbook: Naiditch, David. Rendezvous with Ada: A Programmer's Introduction. Wiley, 1989. 477p. (ISBN: 0-471-61654-0; $39,95/paper) (Required), Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
Florida International University
|
|
Objective: Provide an introduction of the Ada language to students. Concept: Abstract Data Types, Exception Handling, Generics, Object-oriented Design, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: IBM PC Compiler: Mainframe Compilers Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
University of Central Florida
|
|
Objective: Introduce students to developing object-oriented software in Ada 95 using methods of program and data abstraction. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Reuse Unlisted Concept(s), Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: A LAN of RS/6000 workstations running AIX Compiler: GNAT Ada 95 Compiler (RS/6000) Textbook: Cohen, Norman. Ada as a Second Language, 2nd Edition, 1996. (Required), Course Lecture Notes, by Dr. David A. Workman. (Required)
University of Central Florida
|
|
Objective: Gives students a good opportunity to: 1)learn how to write quality code; 2) gain experience in applying the principles of OO analysis and design; and 3) work as a team to develop software using sound software engineering priciples and methods. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: PC Network Compiler: GNAT Ada 95, RR SOftware, Janus/Ada 95 Textbook: Cohen, Norman. Ada as a Second Language, 2nd Edition, 1996. (Required), Rumbaugh, et al. Object-Oriented Modeling & Design. Prentice-Hall, 1991. (Optional)
University of Central Florida
|
|
Objective: Teach software engineering so students learn design principles and developmental techniques. Concept: Abstract Data Types, Design Concepts, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Development Process, Software Engineering, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Compiler: Verdix Textbook: Coad. Object-Oriented Analysis. Prentice-Hall. (Required), Pressman, Roger. Software Engineering: A Practitioner's Approach. McGraw-Hill, 3rd ed., 1991 (Required)
University of Central Florida
|
|
Objective: Provide basic understanding of entire language. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Employee, General Public, Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: VAX Compiler: DEC - VAX Ada Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Gonzalez, Dean W. Ada Programmer's Handbook. Benjamin-Cummings, 1991. (ISBN: 0-8053-2529-8; $13.95/paper) (Optional)
University of Florida
|
|
Objective: To introduce computer science to first-year computer-science majors and to get them ready for courses that are degree requirements for the computer-science degree. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Packages, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Sun Textbook: Computer Science Overview. Addison-Wesley. (Required)
University of South Florida
|
|
Objective: To introduce computer science to first-year computer-science majors and to get them ready for courses that are degree requirements for the computer-science degree. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Packages, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Sun Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
University of South Florida
|
|
Objective: Introduce students to software engineering using the Ada language with emphasis on the embedded-system environment. Programming techniques in Ada are emphasized. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer, System Analyst Computer: Sun Sparcstations Compiler: TeleSoft-Sun 4, TeleSoft, Alsys Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
University of West Florida |
|
Concept: Abstract Data Types, Design Concepts, Packages, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: Alsys RiscAda, GNAT Ada on Sun Textbook: Rudd, David. Introduction to Software Design & Development with Ada. West, 1993. (ISBN: 0-314-02829-3) (Required)
Armstrong Atlantic State University
|
|
Objective: Comparative study of programming languages, including a more detailed look at Ada, C++, and Lisp. Concept: Abstract Data Types, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Reuse Unlisted Concept(s), Tasking Audience: Student Background: Student (attending college/university) Computer: Solaris-2 Compiler: Alsys Textbook: Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Required)
Armstrong Atlantic State University |
|
Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: TeleGen 2, Alsys
Armstrong Atlantic State University
|
|
Concept: Abstract Data Types, Design Concepts, Packages, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: Alsys RiscAda, GNAT Ada on Sun Textbook: Rudd, David. Introduction to Software Design & Development with Ada. West, 1993. (ISBN: 0-314-02829-3) (Required)
Armstrong Atlantic State University
|
|
Objective: Abstraction of features from several languages. New languages introduced: Ada, Lisp. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: 486 PC Compiler: AETECH Learn Ada Compiler and Manual Textbook: Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Required)
Columbus State University
|
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact Michael B. Feldman of George Washington University at mfeldman@seas.gwu.edu. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Covenant College |
|
Objective: Emphasize the relationship of Ada constructs to the corresponding software engineering principles, learn to program using these constructs. Concept: Abstract Data Types, Exception Handling, Generics, Multi-tasking, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM RISC 6000 Compiler: IBM AIX Ada/6000
Georgia Southwestern State University
|
|
Concept: Domain Analysis, Object-oriented Design, Reuse Software Developing, Unlisted Lesson(s) Audience: Student Background: Computer Scientist, Student (attending college/university), System Analyst Computer: PC, Network Compiler: Programming Languages: C, C++, ObjectPAL, Visual Basic Tool: Systems Architect Textbook: Page-Jones, Meiler. The Practical Guide to Structured Systems Design. Yourdon Press, 2nd ed., 1988. (Required)
Georgia State University
|
|
Concept: Domain Analysis, Reuse Software Developing, Unlisted Lesson(s) Audience: Student Background: Computer Scientist, Student (attending college/university), System Analyst Computer: PC, Network, Systems Architect Compiler: Systems Architect Tool: Languages used: C, C++, ObjectPAL, Visual Basic Textbook: Page-Jones, Meiler. The Practical Guide to Structured Systems Design. Yourdon Press, 2nd ed., 1988. (Required)
Georgia State University
|
|
Concept: Domain Analysis, Reuse Software Developing, Unlisted Lesson(s) Audience: Student Background: Computer Scientist, Student (attending college/university), System Analyst Computer: PC, Network Compiler: Programming Languages: C, C++, ObjectPAL, Visual Basic Tool: Systems Architect Textbook: Page-Jones, Meiler. The Practical Guide to Structured Systems Design. Yourdon Press, 2nd ed., 1988. (Required)
Georgia State University
|
|
Objective: Teach problem analysis and programming with Ada. Covers Ada fundamentals including types, packages, tasks, exceptions and generic program units. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Software Development Process, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Macintosh, PCs Compiler: Meridian Ada, IntegrAda Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Cohen, Norman C. Ada as a Second Language. McGraw-Hill, 1986. 838p. (ISBN: 0-07-011589-3; $36.04/paper) (Optional)
Morris Brown College
|
|
Objective: Provide a course in standard data structures and algorithms. Presents introduction to programming in Ada language. Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Real-time Programming, Strong Typing Audience: Student Background: Computer Scientist Computer: Pentium 486 Compiler: Janus Ada, Meridian Open Ada Textbook: Stubbs and Webre. Data Structures with Abstract Data Types and Ada. PWS-Kent. 1993. (Required)
Oglethorpe University
|
|
Objective: Introduce Ada to computer-science students. Features software engineering. Concept: Abstract Data Types, Design Concepts, Exception Handling, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: PCs, workstations Compiler: Meridian, Alsys Textbook: Gehani, Narain. Ada: Concurrent Programming. 2nd edition. Silicon, 1991. 230p. (ISBN: 0-929306-08-2; $30.95/trade) (Required), Shumate, Kenneth C. Understanding Ada. 2nd edition. Wiley. (ISBN: 0-471-605-204; $51.00/text) (Required)
Southern Polytechnic State University
|
|
Objective: To examine how the features of Ada facilitate the construction of large, reliable, multi-threaded systems. Concept: Abstract Data Types, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Reuse Unlisted Concept(s), Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: SPARC 5's Compiler: GNAT Textbook: Cohen, Norman. Ada as a Second Language, 2nd Edition, 1996. (Required)
University of Hawaii
|
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Briar Cliff College |
|
Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Software Engineer/Developer, Student (attending college/university) Computer: Sun Compiler: TeleGen Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required), Gonzalez, Dean W. Ada Programmer's Handbook and Language Reference Manual. Benjamin-Cummings, 1991. 200p. (ISBN: 0-8053-2528-X; 19.95/paper) (Optional)
Mount Mercy College
|
|
Objective: Teach concurrent programming concepts, Ada tasking model, Ada 9X protected type & programming for real-time scheduling and race controls in concurrent programming language. Concept: Abstract Data Types, Design Concepts, Multi-tasking, Object-oriented Design, Real-time Programming, Reuse Unlisted Concept(s), Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: PC, VAX, MMX, Sun Workstations Textbook: Gehani, Narain. Ada: Concurrent Programming. 2nd edition. Silicon, 1991. 230p. (ISBN: 0-929306-08-2; $30.95/trade) (Required)
Illinois Institute of Technology
|
|
Objective: Provide an introduction to the principles of software engineering, and implementation of these principles using Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: VAX 6440, VMS Compiler: DEC Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
Parks College of St. Louis University |
|
Objective: Introduction to Ada programming. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM RS/6000 Compiler: IBM AIX Ada/6000 - Release 2.0 Textbook: Watt, David A., et al. Ada Language and Methodology. Prentice-Hall, 1987. 515p. (ISBN: 0-13-004078-9; $39.50) (Required)
Southern Illinois University - Edwardsville
|
|
Objective: Characterize and evaluate different programming languages. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: Sun Sparcstations, IBM 3090 Textbook: MacLennan. Principles of Programming Languages. HRW Publishers, 1987. (Required)
University of Illinois - Chicago |
|
Objective: A traditional senior-level course in the software life cycle, with a large group project. Also introduces Ada. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Exception Handling, Generics, Multi-tasking, Packages, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: GNAT Ada 95 Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required), Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required)
University of Illinois - Chicago
|
|
Concept: Reuse Unlisted Concept(s) Audience: Student Background: Student (attending college/university)
University of Illinois at Urbana - Champaign |
|
Objective: Teaches the design techniques needed to make reusable OO designs Concept: Object-oriented Design, Reuse Unlisted Concept(s) Audience: Student Background: Software Engineer/Developer, Student (attending college/university)
University of Illinois at Urbana - Champaign |
|
Concept: Reuse Unlisted Concept(s) Audience: Student Background: Student (attending college/university)
University of Illinois at Urbana - Champaign |
|
Objective: Introduce students to the principles of programming languages and features of advanced languages such as Ada, C++, and ML. Concept: Abstract Data Types, Exception Handling, Generics, Object-oriented Design, Packages, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC RISC Compiler: Verdix Textbook: Sethi. Programming Language Concepts and Constructs. (Required)
Ball State University
|
|
Objective: Present the design and analysis of algorithms that act on data and file structures. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Software Engineering Audience: Student Background: Computer Scientist Compiler: VAX Ada Textbook: Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Required)
Indiana - Purdue University |
|
Objective: Provide an introduction to computer science and the fundamentals of structured programming in a high-level language. Concept: Abstract Data Types, Design Concepts, Problem Solving, Software Development Process, Software Engineering Audience: Student Background: Computer Scientist, Software Engineer/Developer Compiler: VAX Ada Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Indiana - Purdue University |
|
Objective: Provide an introduction to computer science and the fundamentals of structured programming in a high-level language. Concept: Abstract Data Types, Generics, Problem Solving, Software Engineering Audience: Student Background: Computer Scientist Compiler: VAX Ada Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Indiana - Purdue University |
|
Objective: Study the design and run-time behavior of several programming languages. Concept: Abstract Data Types, Design Concepts, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Compiler: VAX Ada Textbook: MacLennan. Principles of Programming Languages. HRW Publishers, 1987. (Required)
Indiana - Purdue University |
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact the institution. Concept: Ada 95 Compatible Issue, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Indiana University Southeast - New Albany |
|
Objective: Provides an overview of Ada packaging and tasking. Concept: Ada 95 Compatible Issue, Packages, Tasking, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Textbook: MacLennan, Bruce. Principles of Programming Languages, 2nd ed. (Required)
Indiana University Southeast - New Albany |
|
Objective: One hour course designed to offer students with computing experience an introduction to Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Tasking Audience: Student Background: Other Background Computer: VAX/PC Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
Purdue University - Calumet
|
|
Objective: A thorough exposure to data structures - arrays, lists, stacks, queues, trees and graphs. Data abstraction, information hiding, algorithm analysis, team software design and implementation. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university) Computer: VAX 6420 Compiler: VAX Ada Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required), Weiss, Mark. Data Structures & Algorithm Analysis in Ada. Benjamin-Cummings, 1993. (ISBN: 0-805-39055-3; $51.75) (Required)
Rose-Hulman Institute of Technology
|
|
Objective: File organization, sequential, direct and indexed file access, external searching and sorting algorithms, hashing. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university) Computer: DEC Alpha Compiler: DEC Ada
Rose-Hulman Institute of Technology
|
|
Objective: Introduce concepts of software engineering and large system development. Introduce Ada and its features for use in engineering design. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Real-time Programming, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, System Analyst Computer: Cluster of VAXen Compiler: VAX VMS Ada
Taylor University
|
|
Objective: Introduce the design of sequential and concurrent algorithms. Software-engineering principles and practices relating to program design and implementation are emphasized. Concept: Abstract Data Types, Design Concepts, Exception Handling, Packages, Software Engineering Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: 386, 486 PCs Compiler: AETECH, LearnAda Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Valparaiso University
|
|
Objective: An introduction to the Ada programming language with emphasis on data abstraction, generic programming, exception handling and tasking. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: VAX 6420, 3B2/1000 Compiler: DEC Ada Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
Eastern Kentucky University
|
|
Objective: Introduction to problem-solving methods and algorithm development using a high-level language. Includes program-design coding techniques, debugging, and internal documentation. First course in problem solving and programming for majors. Concept: Design Concepts, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Gateway 2000 486SX25 Compiler: AETECH IntegrAda Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Murray State University
|
|
Objective: Continue development of discipline in programming design. Includes string processing, recursion, search and sort, sub-programs, and file handling. Course stresses team approach and top-down design. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: 486SX-33 Compiler: AETECH IntegrAda, LINUX-Ada Tool: Ada-Tutor Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Murray State University
|
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Northern Kentucky University
|
|
Objective: To emphasize and demonstrate the power of Ada 9X as a major tool to build better, more reliable, time-critical, reusable large software systems. The significance of reusable, reengineering, and complete object-oriented methodologies are emphasized. Concept: Abstract Data Types, Ada 95 Compatible Issue, Annexes, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: Rational Apex Compiler: VAX Ada, RISC 6000 Ada Tool: 1 Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required), Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Optional)
Grambling State University
|
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contactthe institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Nicholls State University
|
|
Objective: Using Ada to design and implement real-time software systems for the model railroad system in our real-time lab. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Packages, Problem Solving, Real-time Programming, Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: Harris Nighthawk 1202 Super-Microcomputer Compiler: HAPSE Textbook: Gehani, Narain. Ada: Concurrent Programming. 2nd edition. Silicon, 1991. 230p. (ISBN: 0-929306-08-2; $30.95/trade) (Required), Burns, A., and A. Wellings. Real-Time Systems and Their Programming Languages. Addison-Wesley, 1990. 575p. (ISBN: 0-201-17529-0; $38.95) (Optional), Shumate, Kenneth C. Understanding Concurrency in Ada. Wiley, 1989. (ISBN: 0-471-60520-4) (Optional)
Southeastern Louisiana University
|
|
Objective: Teaches beginning programmers to solve problems using a program with good software quality written in Ada. Concept: Design Concepts, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: GNAT Tool: debugger Textbook: Rudd, David. Introduction to Software Design & Development with Ada. West, 1993. (ISBN: 0-314-02829-3) (Required)
University of New Orleans |
|
Objective: Introduce structured programs, abstract data types, analysis of algorithms. Concept: Reuse Software Certifying, Reuse Software Developing, Reuse Software Testing Audience: Student Background: Student (attending college/university)
Bentley College |
|
Objective: Review of basic data structures, data-structure support in machine architectures and high-level languages, data abstraction and its implementation in different languages, data structures for distributed systems, and database design, multi-access databases Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Software Engineer/Developer, Student (attending college/university) Computer: Digital VAX Compiler: DEC Ada Textbook: Booch, Grady. Software Components With Ada: Structures, Tools, and Subsystems. Benjamin-Cummings, 1987. 635p. (ISBN: 0-8053-0610-2) (ISBN: 0-8053-0609-9; $35.50/paper) (Required), Booch, Grady. Object Oriented Design with Applications. 2nd edition. Benjamin-Cummings, 1994. (ISBN: 0-8053-5340-2; $49.50) (Optional)
Boston University
|
|
Objective: Concept of the software product life cycle; various form of a software product from requirment definition through operations and maintenance. Life-cycle models and th actibities performed in each phase. Role of rapid prototyping in requirements analysis and design. Structured and object-oriented software design. Real-time software design. Comparative evaluation of requiremtns definition and design methods. Analysis and design validation. Small-team (5-7 per team) project involving requirements definition, architectural and detailed design. Concept: Design Concepts, Real-time Programming, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Tool: TEAMWORK by Cadre Technologies
Boston University
|
|
Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: VAX 8530, PC's (7300), Sun Workstations Compiler: VAX Ada Tool: Sample Packages Textbook: Reference Manual for the Ada Programming Language. (MIL STD 1815A 1983 Ser.) USGPO, 1983. 344p. (ISBN: 0-318-11823-8) (Required)
Fitchburg State College
|
|
Objective: Introduce Ada as a programming language and as a tool for modeling object-based problem solutions. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM PC (386), Vax 3600 Compiler: Janus Ada (R.R. Software), VAX Ada Tool: Development tools Textbook: Watt, David A., et al. Ada Language and Methodology. Prentice-Hall, 1987. 515p. (ISBN: 0-13-004078-9; $39.50) (Required)
North Adams State College
|
|
Objective: To examine the development and implementation of abstract data types using the object-based features of Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM PC (386), Vax 3600 Compiler: Janus Ada (R.R. Software), VAX Ada Tool: Development tools Textbook: Watt, David A., et al. Ada Language and Methodology. Prentice-Hall, 1987. 515p. (ISBN: 0-13-004078-9; $39.50) (Required)
North Adams State College
|
|
Objective: A software-engineering course that introduces an object-based approach to software design, implementation, testing, and maintenance. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM PC (386), Vax 3600 Compiler: Janus Ada (R.R. Software), VAX Ada Tool: Development tools Textbook: Watt, David A., et al. Ada Language and Methodology. Prentice-Hall, 1987. 515p. (ISBN: 0-13-004078-9; $39.50) (Required)
North Adams State College
|
|
Objective: Introductory CS course. Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Computer Scientist, Manager/Administrator, Other Background, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: PCs/VAX, VMS Compiler: Alsus Ada (ActivAda), Digital Equipment Ada Textbook: Dale, Lilly, & McCormick. Ada Plus Data Structures. D.C. Heath, 1994. (Required), Naps. Introduction to Computer Science: Programming, Problem Solving and Data Structures. West Publishing, 1992. (Required)
Salem State College |
|
Objective: Introductory CS course. Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Computer Scientist, Manager/Administrator, Other Background, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: PCs/VAX, VMS Compiler: Alsys Ada (ActivAda), Digital Equipment Ada Textbook: Dale, Lilly, & McCormick. Ada Plus Data Structures. D.C. Heath, 1994. (Required), Naps. Introduction to Computer Science: Programming, Problem Solving and Data Structures. West Publishing, 1992. (Required)
Salem State College |
|
Concept: Abstract Data Types, Design Concepts, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Computer Scientist, Manager/Administrator, Other Background, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: PCs/VAX, VMS Compiler: Alsys Ada (ActivAda), Digital Equipment Ada Textbook: Dale, Lilly, & McCormick. Ada Plus Data Structures. D.C. Heath, 1994. (Required), Naps. Introduction to Computer Science: Programming, Problem Solving and Data Structures. West Publishing, 1992. (Required)
Salem State College |
|
Objective: Focus on syntax and mechanics of the Ada language, emphasizing packages. The course is a co-requisite for Computer Science II course. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: IBM-compatible PCs, Data General MV 1000 Compiler: Data General (Rolm) Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Western New England College
|
|
Concept: Abstract Data Types, Design Concepts, Exception Handling, Multi-tasking, Problem Solving, Software Development Process, Strong Typing, Tasking Audience: Other Audience, Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university) Computer: DEC terminals, PCs, workstations Compiler: DEC/VMS Ada
Bowie State University
|
|
Objective: Teach the fundamentals of Ada programming. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Problem Solving Audience: Student Background: Computer Scientist Computer: IBM 486 Compiler: Meridian Ada Textbook: Cohen, Norman C. Ada as a Second Language. McGraw-Hill, 1986. 838p. (ISBN: 0-07-011589-3; $36.04/paper) (Required)
Montgomery College |
|
Objective: Upon the successful completion of the course, the student should know Ada programming language and how to program in Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: VAX Compiler: VAX Ada Textbook: Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Required)
Morgan State University |
|
Objective: Study software engineering with Ada as adjunct topic in support of object-oriented, design, and real-time requirements. Concept: Design Concepts, Management Overview, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Vax, PC Compiler: VAX Ada, Meridian PC Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
Towson State University |
|
Objective: Please contact school for more information. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
University of Maryland - University College
|
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
University of Maryland - University College
|
|
Objective: The concepts of object-oriented programming are explored and implemented using Ada 95. The principles of concuurent programming are studied and implemented with Ada 95 features. Concept: Abstract Data Types, Design Concepts, Generics, Multi-tasking, Object-oriented Design, Packages, Real-time Programming, Tasking Audience: Student Background: Student (attending college/university) Computer: UNIX platform Compiler: Ada 95 GNAT Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
University of Maryland - University College
|
|
Objective: Teach fundamental concepts of programming languages, with a focus on various paradigms and experience working with various models of those paradigms. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: VAX 4200, Macintoshes; PC Clones Textbook: Dershem & Jipping. Programming Languages: Structures & Abstractions. Wadsworth, 1990. (Required)
Albion College
|
|
Objective: Present a survey of features of modern high-level programming languages. We utilize a text that provides examples in several different languages. The practical part of the course is to explore those same concepts in Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Sparc II, Sparc IPC Workstations Compiler: Tartan Labs, sun 3-60, Ada Compiler Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Sethi. Programming Language Concepts and Constructs. (Required)
Calvin College
|
|
Objective: Introduces students to the concepts of programming in Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: 486 PCs, Macintosh Compiler: GWAda, Meridian Ada Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
Eastern Michigan University
|
|
Objective: Class produces a systems report which includes: 1) defining user needs/opportunities 2) designing the required outputs 3) developing the processes and data that is required 4) creating the time period systems flows 5) writing the user manuals 6) writing the operations manuals and 7) writing the implementation plan. Concept: Domain Analysis, Reuse Business Value, Reuse Software Certifying, Reuse Software Developing, Reuse Software Legal Issues, Reuse Software Testing Audience: Student Background: Student (attending college/university) Computer: 486, 8 mg, Windows 3.1
Ferris State University
|
|
Objective: Students will know the paradigms of languages to better use, choose, and design programming languages. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Packages, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Sun Sparcstations Compiler: GNAT Textbook: Dersham & Jipping. Programming Languages: Models and Structures: 1995. (Required)
Hope College
|
|
Objective: Provide understanding of the underlying principles, structure, and operating environment of modern programming languages. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: VAX 8700, 8650, 6620 workstations & terminals Compiler: DEC VAX Textbook: Caverly, P., and P. Goldstein. Introduction to Ada: A Top Down Approach for Programmers. Brooks-Cole, 1986. 237p. (ISBN:0-534-05820-5; $28.95/paper) (Required), Ghezzi & Jazyeri. Programming Language Concepts. John Wiley & Sons. (Required)
Western Michigan University |
|
Objective: Introduces computer problem solving strategies and ways of reasoning about programs. Objective is to study and use elementary data structures like arrays and records. Concept: Design Concepts, Problem Solving, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC Alpha Compiler: DEC Ada Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
St. Cloud State University
|
|
Objective: Provides experience in addressing larger programming problems, description of abstract data types and recursion, to linear data structures and their representations, intro to use of dynamically allocated linked data structures, connection of ideas from math and computer science. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC Alpha Compiler: DEC Ada Textbook: Naps, Thomas L. Introduction to Data Structures and Algorithm Analysis (Second Addition). St. Paul: West Publishing Company, 1992. (Required), Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
St. Cloud State University |
|
Objective: The application of theory, abstraction and design to data structures and algorithms. Data structures and algorithms studied include general trees, balanced binary trees, graphs and networks, and internal sorting. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Development Process Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: VAX, DEC Alpha Compiler: VAX Ada Textbook: Naps. Introduction to Computer Science: Programming, Problem Solving and Data Structures. West Publishing, 1992. (Required), Cohen, Norman C. Ada as a Second Language. McGraw-Hill, 1986. 838p. (ISBN: 0-07-011589-3; $36.04/paper) (Optional)
St. Cloud State University |
|
Objective: Algorithm analysis and programming techniques used for file processing and data base creation. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Development Process Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: VAX, DEC Alpha System Compiler: VAX Ada Textbook: Miller, Nancy E., and Charles G. Peterson. File Structures With Ada. Benjamin-Cummings, 1990. (ISBN-8053-0440-1; $39.95/text) (Required), Cohen, Norman C. Ada as a Second Language. McGraw-Hill, 1986. 838p. (ISBN: 0-07-011589-3; $36.04/paper) (Optional)
St. Cloud State University |
|
Objective: Design and implementation of large-scale software using software-engineering principles. Concept: Abstract Data Types, Design Concepts, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: VAX 4000 Textbook: Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required)
Winona State University
|
|
Objective: Emphasis on advanced data types, data structures and file types. Includes stacks, queues, graphs, binary search trees, AVL trees, B-trees, file structures and external sorting. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: PCs, DEC 5000 Compiler: Meridian, DEC Textbook: Miller, Nancy E., and Charles G. Peterson. File Structures With Ada. Benjamin-Cummings, 1990. (ISBN-8053-0440-1; $39.95/text) (Required)
Southwest Baptist University |
|
Objective: Provides experience in the designing, development and implementation if a non-trivial commercial quality software package. Concept: Domain Analysis, Reuse Business Value, Reuse Software Developing, Reuse Software Legal Issues Audience: Student Background: Student (attending college/university) Computer: Pentium PC, DEC 5000 with motif Textbook: Pressman, Roger. Software Engineering: A Practitioner's Approach. McGraw-Hill, 3rd ed., 1991 (Required)
Southwest Baptist University |
|
Objective: Enhances student's problem solving, communication and software engineering skills. Concept: Domain Analysis, Reuse Business Value, Reuse Software Developing, Reuse Software Legal Issues Audience: Student Background: Student (attending college/university) Computer: Pentium PC, DEC 5000 with motif Textbook: Pressman, Roger. Software Engineering: A Practitioner's Approach. McGraw-Hill, 3rd ed., 1991 (Required)
Southwest Baptist University
|
|
Objective: Learn syntax and semantics of Ada, the basics of algorithm construction, program development, top-down design, and structured programming. Concept: Design Concepts, Exception Handling, Packages, Problem Solving, Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: IBM PS/2 (386, 486) Compiler: Open Ada (Meridian) Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Truman State University
|
|
Objective: This institution introduces Ada at a CS2 level or data structures course. Ada is not taught as a first language. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
University of Missouri - Columbia
|
|
Objective: Teaches Sophomores and Juniors how to program in Ada. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Packages, Problem Solving, Software Development Process, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: Sun, PC Compiler: Meridian on Sun, Janus on PC Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Mississippi State University
|
|
Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM Clones, Sun Compiler: Janus on PC, Meridian on Sun Tool: Teamwork Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
Mississippi State University
|
|
Objective: To teach system development through software-engineering principles. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: IBM RISC 6000, DEC 3100, micros Compiler: AIX Ada, DEC Ada, Rational Ada, GW-Ada Tool: Rational Ada Package Textbook: Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required), Brooks. Mythical Manmonth (Optional)
University of Southern Mississippi
|
|
Objective: Continuation of Software Engineering I. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: IBM RISC 6000, DEC 3100, micros Compiler: AIX Ada, DEC Ada, Rational Ada, GW-Ada Tool: Rational Ada Package Textbook: Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Required), Brooks. Mythical Manmonth (Optional)
University of Southern Mississippi
|
|
Objective: Teaches the Ada programming language to software engineering students so they can complete their assignments for the associated lecture class. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: IBM RISC 6000 Compiler: AIX Ada, DEC Ada, Rational Ada Tool: Rational Apex Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
University of Southern Mississippi
|
|
Objective: First in a four course sequence that provides an integrated coverage of computer science. Includes algorithms, data structures, discrete math, theoretical cs, and ethics. Concept: Abstract Data Types, Annexes, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Software Developing, Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: 486/586-class PCs as stand-alone MS Windows machines or as UNIX terminals via the excursion software. Compiler: GNAT Ada 95, AdaMagic student edition Textbook: Feldman, Michael B. and Elliot B. Koffman. Ada 95 Problem Solving and Program Design. 2nd Edition. Addison-Wesley, 1996. (Required), Weiss, Mark. Data Structures & Algorithm Analysis in Ada. Benjamin-Cummings, 1993. (ISBN: 0-805-39055-3; $51.75) (Required)
Montana State University
|
|
Objective: Second ina four course sequence that provides an integrated coverage of computer science. Includes algorithms, data structures, discrete math, theoretical cs, and ethics. Concept: Abstract Data Types, Annexes, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: 486/586-class PCs usable as stand-alone MS Windows machines or as UNIX terminals via the excursion software. Compiler: GNAT Ada 95, AdaMagic student edition Textbook: Feldman, Michael B. and Elliot B. Koffman. Ada 95 Problem Solving and Program Design. 2nd Edition. Addison-Wesley, 1996. (Required), Weiss, Mark. Data Structures & Algorithm Analysis in Ada. Benjamin-Cummings, 1993. (ISBN: 0-805-39055-3; $51.75) (Required)
Montana State University
|
|
Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: UNIX, PCs Compiler: DEC Ada, GNAT Ada 95
Montana State University
|
|
Objective: The first course for CS majors and minors covering tools used in advanced study: program design, analysis, and implementation in Ada; UNIX fundamentals; the Internet; and the World Wide Web. Concept: Abstract Data Types, Design Concepts, Exception Handling, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: 486/586 class PCs Compiler: GNAT Ada 95, Ada Magic student edition Textbook: Feldman, Michael B. and Elliot B. Koffman. Ada 95 Problem Solving and Program Design. 2nd Edition. Addison-Wesley, 1996. (Required)
Montana State University
|
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
University of Montana
|
|
Objective: To cover the major features of the language, emphasizing Ada's unique features. Concept: Exception Handling, Generics, Object-oriented Design, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: DEC VAX 4000 Compiler: DEC Ada Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required)
East Carolina University
|
|
Objective: Develop a disciplined approach to designing, coding, and testing of programs, with topics including data abstraction, linked lists, stacks, queries, trees, searching, and sorting. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering Audience: Student Background: Student (attending college/university) Computer: Sequent Symmetry Compiler: Software Leverage, Inc., Sequent Ada Textbook: Feldman, Michael B., and Elliot B. Koffman. Ada Problem Solving & Program Design. Addison-Wesley, 1993. (ISBN: 0-201-52279-9; $43.25/paper) (Required)
Fayetteville State University
|
|
Objective: A rigorous introduction to a disciplined approach to algorithm development, program design, coding, and documentation using Ada. The first course for computing majors and minors. Concept: Abstract Data Types, Design Concepts, Problem Solving, Strong Typing Audience: Student Background: Student (attending college/university) Computer: VAX Cluster Networking System Compiler: VAX Ada Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
Lenoir - Rhyne College
|
|
Objective: A continuation of a disciplined programming approach using Ada. Teaches data abstraction using linked lists, stacks, queues, and trees, and introduces recursion, searching, and sorting. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC MicroVAX Cluster Compiler: VAX Ada
Lenoir - Rhyne College
|
|
Objective: Covers design, implementation and analysis of data structures introduced in Computer Science I & II (CSC 150/155). Graphs, memory management, sorting, searching, algorithm analysis, program correctness. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC MicroVAX Cluster Compiler: VAX Ada Textbook: Weiss, Mark. Data Structures & Algorithm Analysis in Ada. Benjamin-Cummings, 1993. (ISBN: 0-805-39055-3; $51.75) (Required)
Lenoir - Rhyne College
|
|
Objective: Introduction to major operating-system principles, including resource management, simple queueing theory, multi-programming, and concurrent processing. Students write a simulated operating system. Concept: Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: DEC MicroVAX Cluster Compiler: VAX Ada Textbook: Silberschatz & Galvin. Operating System Concepts. Addison-Wesley, 1994. (Required)
Lenoir - Rhyne College
|
|
Objective: To introduce object-oriented principles and processes in design, implementation, testing and maintenance of software products. Teach the Ada language and emphasize its features for software engineering and reuse as well as integrate Ada into object-oriented and reuse-driven project development. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: IBM PC, VAX Compiler: Janus/Ada9X, VAX/VMS Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required)
North Carolina A&T State University
|
|
Objective: Part one of a two-part sequence, this course sequence integrates software engineering methodology, software reuse and Ada 95 together, trains students by individual and team projects which are similar to an industrial environment, and requires students to implement all projects sing Ada 95. This course sequence covers topics in the ACM/IEEE Computing Curriculum. Concept: Ada 95 Compatible Issue, Object-oriented Design, Reuse Unlisted Concept(s), Software Engineering, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
North Carolina A&T State University
|
|
Objective: Oart two of a two part sequence, this course sequence integrates software engineering methodology, software reuse and Ada 95 together, trains students by individual and team projects which are similar as an industrial environment, requires them to implement all projects using Ada 95. This course sequence covers topics in the ACM/IEEE Computing Curriculum software engineering requirements, emphasizes object-oriented technology, and promotes Ada 95 applications. Concept: Ada 95 Compatible Issue, Object-oriented Design, Reuse Software Developing, Reuse Unlisted Concept(s), Software Engineering, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
North Carolina A&T State University
|
|
Objective: To teach Ada as a programming language that emphasizes software-engineering principles. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: VAX-II Compiler: VAX Ada Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Optional)
Western Carolina University
|
|
Objective: Describe and motivate more recent thinking on programming. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Microcomputers Compiler: Meridian on IBM Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Booch, Grady. Software Components With Ada: Structures, Tools, and Subsystems. Benjamin-Cummings, 1987. 635p. (ISBN: 0-8053-0610-2) (ISBN: 0-8053-0609-9; $35.50/paper) (Required)
North Dakota State University
|
|
Objective: Introduce object-oriented systems. Discussion of their advantages and limitations. Concept: Abstract Data Types, Design Concepts, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: Microcomputers Compiler: Meridian on IBM Textbook: Booch, Grady. Object Oriented Design with Applications. 2nd edition. Benjamin-Cummings, 1994. (ISBN: 0-8053-5340-2; $49.50) (Required), Rumbaugh, et al. Object-Oriented Modeling & Design. Prentice-Hall, 1991. (Required)
North Dakota State University
|
|
Objective: Continuation of Computer Programming I. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Compiler: Sun 670 Tool: Library & programming-development tools Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
University of North Dakota
|
|
Objective: Introduces students to computer science and programming using Ada. Top down design concepts are emphasized. Concept: Abstract Data Types, Design Concepts, Exception Handling, Packages, Problem Solving, Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Compiler: GNAT Textbook: Savitch, W.J., et al. Ada: An Introduction to the Art and Science of Programming. Benjamin-Cummings, 1992. (ISBN: 0-8053-7070-6; $33.95/paper text) (Required)
University of North Dakota
|
|
Objective: Study traditional data structures and algorithms, but from an abstract-data-type point of view. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: DEC MicroVAX 3800, DEC System 5400 Compiler: DEC Ada for VMs and Ultrix Textbook: Booch, Grady. Software Components With Ada: Structures, Tools, and Subsystems. Benjamin-Cummings, 1987. 635p. (ISBN: 0-8053-0610-2) (ISBN: 0-8053-0609-9; $35.50/paper) (Required)
Daniel Webster College |
|
Objective: Study traditional data structures and algorithms, but from an abstract-data-type point of view. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: DEC MicroVAX 3800, DEC System 5400 Compiler: DEC Ada for VMS and Ultrix Textbook: Booch, Grady. Software Components With Ada: Structures, Tools, and Subsystems. Benjamin-Cummings, 1987. 635p. (ISBN: 0-8053-0610-2) (ISBN: 0-8053-0609-9; $35.50/paper) (Required)
Daniel Webster College |
|
Objective: Presents an introduction to the concepts of programming. Concept: Design Concepts, Packages, Software Engineering Audience: Student Background: Computer Scientist Computer: DEC MicroVAX 3800, DEC System 5400 Compiler: DEC Ada for VMS and Ultrix Textbook: Delillo, Nicholas J. A First Course in Computer Science with Ada. Irwin, 1993. (ISBN: 0-256-12538-4) (Required)
Daniel Webster College |
|
Objective: Recognize features that make Ada distinct from other programming languages. Read, write, and debug programs using those features. Concept: Abstract Data Types, Design Concepts, Exception Handling, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Strong Typing Audience: Student Background: Computer Scientist Computer: PCs Compiler: Janus Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
Atlantic Community College
|
|
Objective: Advanced concepts in object-oriented techniques and programming-in-the-large principles of concurrency. Concept: Abstract Data Types, Design Concepts, Generics, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Engineering, Tasking Audience: Student Background: Student (attending college/university) Computer: PC with DOS Compiler: Ada Student, Meridian, Janus Ada Textbook: B. Meyer. Object-Oriented Software Construction. Prentice-Hall. (Optional), Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Optional)
College of New Jersey
|
|
Objective: To teach software-engineering practices, supported by the use of the Ada programming language. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: DEC Workstations Compiler: Digital VAX Tool: DEC Debugger Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required), Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Optional)
Fairleigh Dickinson University |
|
Objective: An introductory, graduate-level course in Software Engineering for first-year grad students in the Masters of Engineering program of the Software Engineering Department at Monmouth University. Major topics are: Software Engineering Overview, Graphical Notation, Software Project Management, Software Requirements, Software Design, Programming Language Issues, Software Reuse, Software Testing, Delivery and Maintenance. Concept: Reuse Unlisted Concept(s), Software Engineering Audience: Student Background: Software Engineer/Developer, Student (attending college/university)
Monmouth University |
|
Objective: The purpose of this course is to explore contemporary topics in systematic software reuse. This includes the impact of Object-Based and Object-Oriented Design and Programming with Ada 83, Ada 95, and C++ along with Domain Engineering on the software development process. The course will concentrate on the practical aspects of applying architecture-centric, domain-specific, library-based reuse methodologies integrated with the software development process to create software systems in an efficient, cost-effective manner. The course will illustrate how object-oriented and domain engineering techniques coupled with domain-specific libraries can be used to effectively develop significant software systems in a short period of time, frequently realizing reuse on the order of 70% or more. Libraries of object-based reusable software components will be used to design and implement solutions to problems. Concept: Domain Analysis, Object-oriented Design, Reuse Software Developing Audience: Student Background: Computer Scientist, Other Background, Software Engineer/Developer, Student (attending college/university) Textbook: Conn, Richard, "Software Reuse - SE 508 - Course Notes, Version 2," 1996, Software Engineering Department, Monmouth University. (Required), Karlsson, Even-Andre (editor), "Software Reuse: A Holistic Approach," 1995, John Wiley and Sons, ISBN 0-471-95819-0. (Required), Tracz, Will, "Confessions of a Used Program Salesman: Institutionalizing Software Reuse," 1995, Addison Wesley Publishing Company, ISBN 0-201-63369-8. (Required)
Monmouth University |
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact the institution. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
Richard Stockton College of New Jersey |
|
Objective: To gain an understanding of the major concepts of the Ada programming language, learn how Ada constructs can be used to produce portable, easily maintained, efficiently designed software. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Multi-tasking, Object-oriented Design, Packages, Real-time Programming, Reuse Unlisted Concept(s), Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Silicon Graphics Indy, running UNIX Compiler: GNAT Textbook: Barnes, J.G.P. Programming in Ada 95. (Addison-Wesley, 1996; ISBN 0-201-87700-7) (Required)
Rowan College of New Jersey |
|
Objective: Instructs freshman students top down in a program language free environment. Content stresses problem solving, modularization and good design habits. Concept: Reuse Business Value, Reuse Software Developing, Reuse Software Testing, Reuse Unlisted Concept(s) Audience: Other Audience, Student Background: Student (attending college/university)
Broome Community College |
|
Objective: Study of architecture and design concepts, including parallel-programming concepts. Concept: Design Concepts Audience: Student Background: Computer Scientist Computer: Sun Sparcstations Compiler: NYU Translator and Interpreter for Ada Textbook: Mano. Computer system Architecture. Prentice-Hall, 3rd ed., 1993. (Required)
Canisius College |
|
Objective: Systematic study of programming languages and their implementations, including applications from various fields. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: Sun Sparcstations Compiler: NYU Translator and Interpreter for Ada Textbook: Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Required), Dershem & Jipping. Programming Languages: Structures & Abstractions. Wadsworth, 1990. (Required), Wilensky. Common Lispcraft. Norton, 1986. (Required)
Canisius College |
|
Objective: To develop techniques for developing and testing large software systems. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: VAX Cluster Compiler: DEC, VAX/VMS Tool: DEC ACS Textbook: Mynatt. Software Engineering with Student Project Guidance. (Required), Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Optional)
City University of New York - Queens College
|
|
Objective: Introduction to software development with Ada 95. Concept: Abstract Data Types, Annexes, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s) Audience: Student Background: Student (attending college/university) Computer: IBM PS/VP-433 DOS workstations Compiler: GNAT Ada95 Tool: GW-GNAT and Ada CAPS Textbook: Naiditch, David. Rendezvous with Ada: A Programmer's Introduction. Wiley, 1989. 477p. (ISBN: 0-471-61654-0; $39,95/paper) (Required), Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Optional)
City University of New York - York College
|
|
Objective: Software engineering and applications development using Ada 95 and case tools: OOAD; ER-modeling; specification and code generation, software reuse and extension. Concept: Ada 95 Compatible Issue, Reuse Unlisted Concept(s), Unlisted Lesson(s) Audience: Student Background: Student (attending college/university) Computer: IBM PS/VP-433 DOS workstations and Sun SparcStation-20 Compiler: GNAT Ada 95, ActivAda for Windows Tool: Rational Rose Ada Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required), White, Iseult. Benjamin/Cummings. Rational Rose Essentials - Using the Booch Method. 1994 (Required), Booch, Grady. Object Oriented Design with Applications. 2nd edition. Benjamin-Cummings, 1994. (ISBN: 0-8053-5340-2; $49.50) (Optional), Sommerville, I. Software Engineering. Addison-Wesley, 4th ed., 1992. (Optional)
City University of New York - York College
|
|
Objective: Introduce Ada syntax and semantics and programming style. Concept: Exception Handling, Generics, Packages, Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: Sun Workstations Compiler: Alsys Ada Textbook: Skansholm, J. Ada from the Beginning. Addison-Wesley, 1988. 617p. (ISBN: 0-201-17522-3; $29.25) (Required)
Ithaca College
|
|
Objective: This institution introduces Ada as the first language taught in an undergraduate computing curriculum. For further information, please contact Michael B. Feldman. Concept: Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
LeMoyne College |
|
Objective: Discuss the design, planning, coding, testing, and maintenance of contemporary software packages. This is done by teams producing specific instances of applications software. Concept: Abstract Data Types, Ada 95 Compatible Issue, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Other Audience, Student Background: Computer Scientist, Software Engineer/Developer, Student (attending college/university), System Analyst Computer: VAX, IBM RISC 6000 Unix Workstations Compiler: VAX Ada, Ada for IBM RISC 6000 Tool: IntegrAda by AETECH Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required), Delillo, Nicholas J. A First Course in Computer Science with Ada. Irwin, 1993. (ISBN: 0-256-12538-4) (Required), Booch, Grady. Object Oriented Design with Applications. 2nd edition. Benjamin-Cummings, 1994. (ISBN: 0-8053-5340-2; $49.50) (Optional)
Manhattan College
|
|
Objective: Course lectures cover Ada concurrency, tasks, and Ada 95 distributed systems and objects. Concept: Ada 95 Compatible Issue, Object-oriented Design, Tasking, Unlisted Lesson(s) Audience: Student Background: Student (attending college/university)
New York University
|
|
Objective: Issues in programming languages; Three Views: Users, Semanticists and Compiler Writers; Paradigms: Imperative, Declarative, Functional, Logic, Object-Oriented, etc.; History and Ideas; Computational Models; Principles of Orthogonality, Qualification and Correspondence; Abstract Syntax; Denotational Semantics; Assignment; Type System; Scope Issues; Runtime systems; Exception Handling; Encapsulation; OOPs; Inheritance; Polymorhphism; Memory Management and Garbage Collection in Lisp; Concurrency; Idioms and Styles: FORTRAN, Pascal, C, Ada 95, C++, Java, and Common Lisp. Concept: Abstract Data Types, Ada 95 Compatible Issue, Exception Handling, Generics, Object-oriented Design, Packages, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Textbook: Ravi Sethi. Programming Languages--Concepts and Constructs, 2nd ed. Addison Wesley. ISBN 0-201-59065-4. (Required), Barnes, J.G.P. Programming in Ada 95. (Addison-Wesley, 1996; ISBN 0-201-87700-7) (Optional)
New York University
|
|
Objective: Advanced types, tasking, object-oriented programming, protected objects, hierarchical libraries Concept: Abstract Data Types, Exception Handling, Multi-tasking, Object-oriented Design, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: HOME COMPUTERS Compiler: DEC ON HOME COMPUTERS Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
Polytechnic University
|
|
Objective: To acquire practical experience in Ada. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Tasking Audience: Student Background: Computer Scientist, Student (attending college/university) Computer: Sun Cluster Compiler: Verdix Ada Textbook: Bray, Gary, and David Pokrass. Understanding Ada: A Software Engineering Approach. (Reprint of 1985 ed.) Krieger, 1992. 368p. (ISBN: 0-89464-744-X; $37.50) (Required)
State University of New York - Buffalo
|
|
Concept: Abstract Data Types, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: GNAT Ada 95 Textbook: Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Required), Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Optional)
State University of New York - New Paltz
|
|
Objective: provide student with the knowledge to allow the evaluation of existing and future languages. Ada 95 is used to illustrate most programming language features. Concept: Abstract Data Types, Exception Handling, Generics, Packages, Problem Solving, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: Sun Workstations Compiler: GNAT Ada 95 Textbook: Sebesta, Robert. Concepts of Programming Languages. Benjamin-Cummings, 2nd ed., 1993. (Required), Barnes, J.G.P. Programming in Ada Plus an Overview of Ada 9X. 4th edition. Addison-Wesley, 1994. 622 pages. (ISBN: 0-201-62407-9; $39.95) (Optional)
State University of New York - New Paltz
|
|
Objective: Learn the syntax/semantics of Ada and methodologies for Ada software specifications and design. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Software Development Process, Tasking Audience: Student Background: Computer Scientist, Software Engineer/Developer Computer: Sun-3, Sun-Sparc, DEC 5000, PC compatibles Compiler: Alsys for Sun-3, Sun-Sparc Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required)
State University of New York - Plattsburgh
|
|
Objective: Study of abstract data types, encapsulation, analysis of space and time complexity. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC VAX, IBM-PC clones Compiler: DEC Ada, GW-Ada Textbook: Dale, Lilly, & McCormick. Ada Plus Data Structures. D.C. Heath, 1994. (Required), Stubbs, Daniel F., and Neil W. Webre. Data Structures with Abstract & Ada. PWS, 1993. (ISBN: 0-534-14448-9; $49.95/text) (Optional)
State University of New York - Plattsburgh
|
|
Objective: Algorithm design and implementation. Concept: Design Concepts, Exception Handling, Packages, Problem Solving, Software Development Process, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC VAX, IBM-PC clones Compiler: DEC Ada, GW-Ada Textbook: Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
State University of New York - Plattsburgh
|
|
Objective: Organization of data with associated algorithms. Concept: Abstract Data Types, Exception Handling, Generics, Object-oriented Design, Packages, Problem Solving, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing Audience: Student Background: Student (attending college/university) Computer: DEC VAX, IBM-PC clones Compiler: DEC Ada, GW-Ada Textbook: Dale, Lilly, & McCormick. Ada Plus Data Structures. D.C. Heath, 1994. (Required), Dale, Nell, et al. Programming and Problem Solving with Ada. Heath, 1994. 975p. (ISBN: 0-669-29360-1) (Required)
State University of New York - Plattsburgh
|
|
Objective: An introduction to real-time computing. Hardware, architecture, systems software, and software-development techniques are discussed. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Multi-tasking, Object-oriented Design, Packages, Problem Solving, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: DEC VAX, DEC RTVax Compiler: DEC Ada, VAXlen Ada Tool: Remote debugger Textbook: Burns, A., and A. Wellings. Real-Time Systems and Their Programming Languages. Addison-Wesley, 1990. 575p. (ISBN: 0-201-17529-0; $38.95) (Required), Rumbaugh, et al. Object-Oriented Modeling & Design. Prentice-Hall, 1991. (Required)
State University of New York - Plattsburgh
|
|
Objective: Teach software-engineering techniques using Ada. Highlights Ada's language features that enhance its usefulness for software engineering. Concept: Abstract Data Types, Exception Handling, Generics, Multi-tasking, Packages, Real-time Programming, Reuse Unlisted Concept(s), Software Development Process, Software Engineering, Strong Typing, Tasking Audience: Student Background: Student (attending college/university) Computer: Zenith PCs, Vax 4000-610 Compiler: Janus, Meridian Textbook: Booch, Grady, and D. Bryan. Software Engineering with Ada. 3rd ed. Benjamin-Cummings, 1994. (ISBN: 0-8053-0608-0; $43.25) (Required), Habermann, A., and Dwayne E. Perry. Ada for Experienced Programmers. (Computer Science Series) Addison-Wesley, 1983. 480p. (ISBN: 0-201-11481-X; $37.75/paper) (Optional)
State University of New York - Potsdam |
|
Objective: Provide an introduction to the theory and design of modern programming languages. Concept: Abstract Data Types, Design Concepts, Exception Handling, Management Overview, Object-oriented Design, Packages, Problem Solving, Strong Typing, Tasking Audience: Student Background: Computer Scientist Computer: VAX 6510 Compiler: DEC Ada
Hiram College |
|
Objective: Introduce students to concepts of large programs, group work, standardization, and modularization. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Other Background Computer: IBM 486 Compiler: Meridian Textbook: Barnes, J. Programming in Ada. 3rd edition. Addison-Wesley, 1989. 494p. (ISBN: 0-201-17566-5; $32.25) (Required)
Mount Union College
|
|
Objective: Match ACM Recommendations Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Manager/Administrator, Other Background Computer: Sun Sparc 2 Compiler: Sun Ada Textbook: Tremblay, J. Introduction to Computer Science. (Required)
Muskingum College |
|
Objective: Provide software-engineering concepts. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Management Overview, Object-oriented Design, Packages, Problem Solving, Software Engineering, Strong Typing, Tasking Audience: Student Background: Computer Scientist, Manager/Administrator, Other Background Computer: Sun Sparc 2 Compiler: Sun Ada Textbook: Tremblay, J. Introduction to Computer Science. (Required)
Muskingum College |
|
Objective: A full-day TRI-Ada tutorial (1993, 1994) that covers reusable component engineering design principles, formal specification, efficient implementation and modular testing and verification based on the RESOLVE/Ada discipline described in Joseph E. Hollingworth's doctoral dissertation (which is provided to participants). Concept: Ada 95 Compatible Issue, Reuse Unlisted Concept(s) Audience: Employee, General Public, Student Background: Computer Scientist, Manager/Administrator, Other Background, Software Engineer/Developer, Student (attending college/university), System Analyst
Ohio State University |
|
Objective: Course available on request. Covers reusable comonent engineering design principles, formal specification, efficient implementation, modular testing and verification; based on the RESOLVE/Ada discipline in Joseph E. Hollingworth's doctoral dissertation (which is provided to attendees). Concept: Ada 95 Compatible Issue, Reuse Unlisted Concept(s), Software Engineering Audience: Employee, General Public, Student Background: Computer Scientist, Manager/Administrator, Other Background, Software Engineer/Developer, Student (attending college/university), System Analyst
Ohio State University |
|
Objective: Teach students to use the RESOLVE/Ada discipline to overcome a variety of problems in creating reusable Ada generic packages. Problems include parameterization, partial instantiation, optimization, testing and verification, and storage-management difficulties such as memory leaks. Concept: Abstract Data Types, Design Concepts, Generics, Management Overview, Object-oriented Design, Packages, Reuse Unlisted Concept(s), Software Engineering, Strong Typing Audience: Student Background: Computer Scientist Computer: Sun Sparc Compiler: Meridian Ada on Sun Sparc Textbook: Hollingsworth, J. E. Software Component Design for Reuse: A Language-Independent Discipline Applied to Ada. Ohio State University, 1992. (Required)
Ohio State University |
|
Objective: Presents a usual data-structures course with emphasis on abstract data types. Concept: Abstract Data Types, Design Concepts, Exception Handling, Generics, Object-oriented Design, Packages, Strong Typing Audience: Student Background: Computer Scientist Computer: Vax-II, DEC Station Compiler: VAX Ada Textbook: Feldman, Michael B. Data Structures with Ada. Prentice-Hall (Reston Imprint), 1985. (ISBN: 0-8359-1220-5) Also Addison-Wesley, 1985. 313p. (ISBN: 0-201-52673-5; $47.50/text) (Required)
Ohio University - Athens |
|
Objective: Teach the principles of software engineering. Concept: Design Concepts, Management Overview, Object-oriented Design, Software Development Process, Software Engineering Audience: Student Background: Computer Scientist Computer: PCs, Macintoshes Compiler: VAX Ada Textbook: Gonzalez, Dean W. Ada Programmer's Handbook. Benjamin-Cummings, 1991. (ISBN: 0-8053-2529-8; $13.95/paper) (Required) |