robust.cs.utep.edurobust.cs.utep.edu/arch1/poster/all-cs-course-outcomes.doc · web viewapply graph...

COURSE DESCRIPTION

Dept., Number CS1401 Course

Title

Introduction to Computer Science

Semester

Hours

45hrs

+ labs

Course Coordinator

Vladik Kreinovich

Current Catalog Description

First course for students majoring in Computer Science. Introduction to problem solving with computers, including representation, control structures, and software development methods; closed laboratory and programming assignments in a high-level language; programming environments; social and ethical aspects of computing.

Textbook

D. S. Malik, Java Programming: Program Design Including Data Structures, Boston: Thomson Course Technology, 2006.

References

NA

Course Outcomes

Level 1: Knowledge and Comprehension

Level 1 outcomes are those in which the student has been exposed to the terms and concepts at a basic level and can supply basic definitions. The material has been presented only at a superficial level.

Upon successful completion of this course, students will be able to:

1a. Explain the role of algorithms in the problem-solving process. 1b. Define the concepts of data and process abstraction, including the concept of abstract data.1c. Describe, at a high level, memory hierarchy and storage systems.1d. Describe, at a high level, data representation in memory, particularly the difference between

the representation of primitive types and reference types and representation of non-numeric data.

1e. Describe or identify basic social and ethical implications of computing, including basic intellectual property issues and historical examples of software risks.

1f. Identify major figures in computing and describe, at a high level, their contributions.1g. Define and explain basic software processes and metrics such as the software life cycle. 1h. Describe the role of software standards and documentation in creating robust and

maintainable software.

1i. Document methods in terms of preconditions, post-conditions, and returns. 1j. Describe, at a high level, major programming paradigms. 1k. Understand the use of programming environments (integrated editors, compilers, interpreters,

debuggers). 1l. Recognize the types of knowledge and skills required of a computer scientist and the major

career options available to computer science graduates.

Level 2: Application and Analysis

Level 2 outcomes are those in which the student can apply the material in familiar situations, e.g., can work a problem of familiar structure with minor changes in the details.


2a. Use the syntax and semantics of a higher-level language to express their solutions to programming problems, including the correct use of:

Variables and assignment to variables Primitive types, e.g., integer, character, and floating-point variable types Commonly-used built-in reference types, e.g., single-dimension Selective control structures, e.g., if and switch Logical and arithmetic operators Iterative control structures, e.g., for and while

2b. Use functions and parameter passing involving both primitive and reference types.2c. Apply problem-solving strategies to design a solution to a problem similar to ones seen

before.2d. Design simple ADTs to solve a problem similar to one seen before.2e. Apply testing and debugging strategies, including black-box and white-box testing, test

drivers, stubs, and test suites, to identify software faults. 2f. Describe numeric data representation and number bases, and convert numbers between bases.2g. Formulate complex logical expressions involving multiple and/or/not combinations. 2h. Implement nested if statements. 2i. Formulate complex arithmetic expressions involving operators of differing precedence and

associativity, and understand the order of evaluation of sub-expressions. 2j. Implement simple ADTs incorporating multiple primitive instance variables and at least one

reference instance variable, with appropriate accessor and modification methods. 2k. Use dynamic memory allocation, e.g., new, to create new objects. 2l. Use simple I/O to read and write character and numeric data to and from files, keyboard, and

display. 2m.Use predefined or built-in exceptions to handle violation of preconditions.2n. Use standard documentation to determine the use of an unfamiliar class or method. 2o. Use teamwork roles and methods in the classroom.

Level 3: Synthesis and Evaluation

Level 3 outcomes are those in which the student can apply the material in new situations. This is the highest level of mastery.

There are no Level 3 outcomes in this course.

Relationship Between Course Outcomes and Program Outcomes

As shown in Table 5b, the course outcomes for CS 1401 contribute to the following program outcomes:

1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.3-1 Participate as a productive member of a team.3-2 Solve common problems in team dynamics.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.4-2 Apply the insights embodied in professional codes of ethics.5-3 Articulate the benefits of graduate studies.

Prerequisites by Topic

MATH 1508 with a grade of C or better.

Students entering the course are assumed to have no background in computer science or programming. They should be familiar with running software applications and using a computer, and they should be familiar with topics from pre-calculus, including algebraic functions and proofs, and base representations of numbers.

Major Topics Covered in the Course

Basics of programming in a higher-level programming language.

Introduction to Computer Science history.

COURSE DESCRIPTION


Title

Elementary Data Structures and Algorithms

Semester

Hours

45hrs + Labs

Course Coordinator

Olac Fuentes


Second course for students majoring in Computer Science. Fundamental computing algorithms, including searching and sorting; elementary abstract data types including linked lists, stacks, queues and trees; introduction to algorithm analysis.

Textbook

D. S. Malik, Java Programming: Program Design Including Data Structures, Boston: Thomson Course Technology, 2006.

References

NA

Course Outcomes




1a. Explain basic or introductory-level notions of a virtual machine.1b. Describe the concept of polymorphism.1c. Use class browsers and related tools.1d. Identify class hierarchies.1e. Recognize the standard terms associated with particular data structures, e.g., head/tail,

push/pop/peek.




2a. Use Big-O notation to express the best-, average- and worst-case behaviors of an algorithm.2b. Examine the structure and use of activation records.2c. Determine best, average and worst-case behaviors of an algorithm.2d. Code and use quadratic and O(n log n) sorting algorithms.2e. Implement recursive algorithms over natural numbers, lists, and trees.2f. Define and use classes, subclasses, and inheritance.2g. Implement a simple graphical user interface.2h. Perform string manipulation and simple parsing.2i. Implement and use multi-dimensional arrays.2j. Analyze the importance of encapsulation and information hiding.2k. Implement applications and simulations using the data structures identified above.2l. Implement simple sequential and binary search algorithms.2m.Implement quadratic sorting algorithms.2n. Contrast memory allocation of integers, real numbers, characters, arrays, and objects.




3a. Design and implement the following data structures as appropriate for a given problem: Multi-dimensional arrays Lists implemented as arrays or linked lists Stacks Queues Binary trees and binary search trees Simple hash tables

3b. Assess time and space trade-offs in algorithms.


As shown in Error: Reference source not found, the course outcomes for CS 2401 contribute to the following program outcomes: 1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.2-3 Formulate and pose incisive, technical questions.


CS 1401 with a grade of C or better.

Students entering the course will have met the learning outcomes for CS 1401.


This is the second course for students majoring in Computer Science. Major topics include:

Fundamental computing algorithms, including searching and sorting Elementary abstract data types including linked lists, stacks, queues, and trees Elementary algorithm analysis

COURSE DESCRIPTION


Title

Data Structures

Semester

hours

45hrs + Labs

Course Coordinator

Martine Ceberio


The definition and implementation of abstract data types; representation of data using sets, lists, trees, and graphs; the design and implementation of traversal, search, and sort algorithms; and the space and time analysis of algorithms.

Textbook

Alfred V. Aho, Jeffrey D. Ullman, John E. Hopcroft, Data Structures and Algorithms, Boston: Addison-Wesley, 1983.

References

NA

Course Outcomes




1a. Describe the characteristics of static, stack, and heap allocation.1b. Explain issues related to disk read/write time.1c. Define strategies for balancing a binary search tree.1d. Define the algorithms for implementing B-tree operations.1e. Define the procedure for conducting an external sort.




2a. Categorize algorithms based on programming strategy, i.e., divide-and-conquer, greedy, backtracking, and dynamic programming strategies.

2b. Analyze iterative and recursive algorithms with respect to time and space.2c. Describe the applications for a dictionary/map ADT, e.g., the application of a symbol table.2d. Give representations for and operations on binary tree, general tree, threaded tree, heap,

binary search tree, B-tree, quad tree, and graphs.2e. Determine the order for a B-tree based on memory issues.2f. Apply graph algorithms for determining shortest paths (Dijkstra's and Floyd's algorithms),

minimal spanning tree (Prim's and Kruskal's algorithms), transitive closure (Floyd's algorithm), and topological sort.

2g. Select an appropriate sorting algorithm for a given situation and defend the selection.2h. Compare and contrast approaches for resolving collisions in hash tables, e.g., linear probing,

quadratic probing, double hashing, rehashing, chaining.2i. Apply design methods and other problem-solving strategies. Examples might include (but are

not limited to) functional decomposition, design patterns, top-down design, abstraction, CRC.




3a. Select data structures and operations associated with abstract data types. 3b. Determine the signature and pre- and post-conditions for operations on an abstract data type. 3c. Given a scenario, describe the abstract data types that could be created.3d. Design and implement binary and binary-search trees, using pre-, post-, or in-order traversals

as appropriate for a given situation. 3e. Judge which data model (list, tree, graph, or set) is appropriate for solving a problem. 3f. Justify the choice of a data structure to solve a problem based on issues such as time, space,

and characteristics of the data structure. 3g. Judge which implementations are best suited for an application that requires a list data model:

doubly-linked lists, circular lists, circular queue, or generalized list. 3h. Judge whether an array or linked implementation is best suited for an application that

requires a tree data model. 3i. Judge which graph representations (adjacency list, adjacency matrix, edge list) are

appropriate for solving a problem. 3j. Develop algorithms that are based on depth- and breadth-first traversal of general trees,

binary trees, and graphs. 3k. Judge which sort algorithm (insertion, selection, merge sort, heap sort, quick sort, radix) is

appropriate for solving a problem. 3l. Judge which search algorithm and data structure is appropriate for solving a problem 3m.Design and implement a recursive solution to a problem.


As shown in Error: Reference source not found, the course outcomes for CS 2402 contribute to the following program outcomes:

1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.2-3 Formulate and pose incisive, technical questions.


CS 2401 and MATH 2300 each with a grade of “C” or better.

Students entering the course will have met the learning outcomes for CS 1401, CS 2401, and Math 2300.


This course is a survey of classic algorithms and data structures, useful for sorting, manipulating graphs, storing data collections and mappings. The course is intended to provide students with a thorough understanding of abstract data types and of representation of data using sets, lists, trees, and graphs; a working knowledge of storage allocation and collection techniques; and an introduction of algorithm analysis.

Major topics include:

Methods for determining correctness and evaluating complexity of algorithms Asymptotic analysis of algorithms; survey of data structures (abstract data types) and

algorithms Implementation of algorithms in application to a wide range of computer science

problems Importance of developing modular code

More specifically, the following core algorithms and data structures will be covered in this course:

Collections: adjacency matrices and lists, hash tables, self-balancing trees (B-trees, AVL trees, Red-Black trees), priority queues

Search and sort algorithms: in particular, the binary search, the insertion sort, bubble sort, heap-sort, quick-sort, merge-sort

Tree traversals: pre-order, post-order, in-order, depth-first search, breadth-first search Graph algorithms: single-source shortest path, all-pairs shortest path, minimum spanning

tree, coloring problem, topological sort

COURSE DESCRIPTION


Title

Junior Professional Orientation

Semester

Hours

15hrs Course Coordinator

Rolfe Sassenfeld


Introduction to the Computer Science profession with a special emphasis on professional ethics. Required of all students prior to graduation.

Textbook

G. Izumo, C. Carter, and C. Ozee, Keys to Career Success: How To Achieve Your Goals, 2nd ed., Upper Saddle River, N. J.: Prentice Hall, 2002.

References

NA

Course Outcomes




1a. Understand the role of post graduate opportunities in reaching career goals.1b. Understand the key components of writing a research paper and presentation.1c. Describe techniques for face-to-face and telephone interviews.1d. Recognize possible career paths, including: a) Co-ops and internships, b) Graduate study and

research, c) Employment in business, d) Employment in government. 1e. Discuss the concepts of ethics in society and software engineering.




2a. Prepare a resume.2b. Inventory personal characteristics such as strengths, weaknesses, and contacts.2c. Analyze goals and future plans, especially with respect to post graduate opportunities.2d. Identify personal preferences in work environments, fields of study, culture, climate, and

other areas.2e. Complete the Career Services Mock Interview Process.2f. Work with Career Services to prepare for and attend interviews. (optional)




3a. Compose a technical report on an issue of professional ethics in computing. 3b. Evaluate an issue of professional ethics in computing and create a presentation. 3c. Prepare a report comparing requirements and characteristics of graduate schools.3d. Prepare a report comparing livability factors in cities. 3e. Prepare a report comparing work environment in companies.



2-1 Present technical information orally.2-2 Write a professional technical report..2-3 Formulate and pose incisive, technical questions.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.4-2 Apply the insights embodied in professional codes of ethics.5-1 Describe the importance of and options available for continuing education. 5-2 Describe the role of professional societies.5-3 Articulate the benefits of graduate studies.


Junior standing required for this course.


Resume writing Goal analysis and career planning skills Identification of personal and professional skills Career path investigation Post-graduate opportunities Environmental preferences influencing career and location choice Contact and interviewing techniques Technical and professional writing Ethics in society and software engineering

COURSE DESCRIPTION


Title

Computer Architecture II: Advanced Computer Design and Implementation

Semester

hours


Pat Teller


The organization and structure and the major hardware components of computers; the mechanics of information transfer and control within digital computer systems.

Textbook

D. Patterson, and J. L. Hennessy, Computer Organization and Design: The Hardware/Software Interface, 3rd ed., San Francisco: Morgan Kaufmann Publishers, an imprint of Elsevier, Inc., 2005.

References

NA

Course Outcomes




1a. Explain the representation of floating-point numbers.1b. Define virtual memory.1c. Discuss interfacing processors and peripherals.1d. Understand multiprocessor systems




2a. Apply knowledge of arithmetic algorithms and real-time scheduling.2b. Analyze cache design.

2c. Examine representation of integer numbers.2d.Level 3: Synthesis and Evaluation



3a. Evaluate computer performance in terms of space and time tradeoffs.3b. Evaluate instruction set architecture design and implementation.3c. Construct datapath and control mechanisms used in processor implementations.3d. Propose processor implementation alternatives (single-cycle, multiple-cycle, and pipelined

implementations) for a particular situation.3e. Prepare memory hierarchy design given certain requirements.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.


CS 3432 and EE 2369 each with a grade of “C” or better.


How computers execute a program What makes execution time smaller on some computers: Performance How execution time is measured for different implementation on a computer system The components of execution time How these components are mapped to the computer architecture How the computer architecture is designed to achieve better performance

COURSE DESCRIPTION


Title

Advanced Object-Oriented Programming

Semester

hours


Yoonsik Cheon


An in-depth exposure to the object-oriented programming paradigm, which builds upon programming experience gained in lower-level computer science classes. Emphasis on programming in an object-oriented language with which students are already familiar, and on requirements, testing, code reading, and comprehension

Textbook

C. Horstmann, Object-Oriented Design and Patterns, 2nd ed., Hoboken, N. J.: John Wiley & Sons, Inc., 2005.

Optional:

S. W. Ambler, The Elements of UML 2.0 Style, Cambridge University Press, 2005. A. Vermeulen, et. al., The Elements of Java Style, Cambridge University Press, 2000.

References

NA

Course Outcomes




1a. Explain the fundamentals of software development including development process, quality of software systems, and challenges of software development.

1b. Define or explain principles of modularity, encapsulation, information hiding, abstraction, and polymorphism.




2a. Use object-oriented design tools such as CRC and UML class diagrams to model problem solutions and to express inheritance, association, aggregation, and composition relationships among classes.

2b. Recognize and use basic object-oriented design patterns to structure solutions to problems.2c. Implement association relationships and multiplicities.2d. Use frameworks, classes, and methods from standard libraries in problem solutions.2e. Design and implement modular solutions to problems in a procedural programming language

such as C.2f. Compare and contrast object-oriented design with procedural design.




3a. Develop modular solutions to a given problem statement.3b. Design and implement software employing the principles of encapsulation, information

hiding, abstraction, and polymorphism.3c. Design, implement, and use classes and methods in an object-oriented programming

language, employing standard naming conventions and making appropriate use of advanced features such as inheritance, exception handling, I/O, references or pointers, and simple GUIs.

3d. Evaluate existing classes and software for the purposes of extension through inheritance.3e. Use and create standard API documents to understand and document the use of classes and

methods.3f. Design and implement thorough test suites (unit testing).3g. Re-factor existing software to improve its design or efficiency.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.2-1 Present technical information orally.2-2 Write a professional technical report.


CS 2402 with a grade of C or better.


The goal of this course is to equip students with advanced design and programming techniques in the object-oriented programming paradigms. To this end, major topics covered include:

Good object-oriented design concepts Knowledge and skills required to develop reusable, quality programs The use of object-oriented design tools such as UML for modeling problem solutions and

complex systems Increasing proficiency in application of advanced programming techniques in object-

oriented environments

Specific topics include the following:

UML Applets Java Features Inheritance in Java Class Design Documenting with Javadoc Unit Testing Design by Contract

COURSE DESCRIPTION

Dept., Number CS3335* Course

Title

Systems Programming

Semester

hours

45hrs Course Coordinator Pat Teller

* This course has been replaced as a required course by CS 4375 Theory of Operating Systems.


The design and implementation of the programming environment including editors, compilers, loaders and linkers, debuggers and operating systems.

Textbook

R. E. Bryant and D. R. O'Hallaron, Computer Systems: A Programmer's Perspective, Upper Saddle River, N. J.: Prentice Hall, 2003.

References

NA

Course Outcomes




1a. Define basic UNIX OS concepts such as: process, program, process groups, signals, running programs, process control, address space, user and kernel modes, system calls, context switching.

1b. Understand methods and the purpose of measuring the execution time of a program.1c. Explain the client-server programming model and how this applies to networks and the

global IP Internet.1d. Describe file access and usage (open, close, read, write, sharing, metadata).




2a. Apply C programming language constructs and grammar to create programs and write system software.

2b. Use makefiles, linking, object files, loading, symbol resolution, shared and static libraries, debugging and execution of programs linked in various forms.

2c. Demonstrate handling of exceptions within a process and to control processes.




3a. Assess the importance of file formats, word sizes, word alignment, hardware characteristics (e.g. processor speeds & memory) when working in an environment with multiple OS & hardware.

3b. Choose among options available in systems programming to provide software updates based on library and language usage. (e.g., shared/static libraries, posix/non-standard development tools, and web technology).

3c. Choose among several tools and concepts from this class that are used to support the development of new programs, in particular makefiles, loaders, linkers, debuggers.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.


CS 2402 with a grade of “C” or better.

Students should know the basic constructs of programming, e.g., data types, control structures, procedures, and functions. Students should know the following computer science concepts: operating systems, files, program, memory, input/output and peripheral devices.


Design and implementation of the programming environment, including operating system and hardware characteristics, makes, compilers, loaders and linkers, debuggers, exceptions, virtual memory, I/O, network and concurrent programming.

Specific topics include the following: Bits and Bytes, Integers, Floating point, Machine-Level Programming (Control Flow, Procedures, Structured Data, and Other Topics), Program Optimization, The Memory Hierarchy, Linking, Virtual Memory, Linux Memory System, Dynamic Memory Allocation, System-Level I/O, Internetworking, Network Programming, Web Services, Concurrent Servers, Programming with Threads.

COURSE DESCRIPTION


Title

Automata, Languages and Computability

Semester

hours


Francois Modave


Theoretical computing models and the formal languages they characterize: Finite state machines, regular expressions, pushdown automata, context-free grammars, Turing machines and computability. Capabilities and limitations of each model, and applications including lexical analysis and parsing.

Textbook

E. Kinber and C. Smith, Theory of Computing: A Gentle Introduction, Upper Saddle River, N. J.: Prentice Hall, 2001. ISBN: 0-13-027961-7.

References

NA

Course Outcomes




1a. Understand the differences between regular languages, context-free languages, recursive, and recursively enumerable languages.

1b. Understand the differences between finite automata, pushdown automata and Turing machines.

1c. Know how to recognize a deterministic machine from a non-deterministic machine.1d. Know which class of languages is accepted by which type of machine.1e. Know the Chomsky hierarchy of languages (finite, regular, context-free, recursive,

recursively enumerable).1f. Know how to build a parse tree or a derivation from a context-free grammar.1g. Understand how a finite automaton can be seen as a special type of pushdown automaton and

how a pushdown automaton can be transformed into an equivalent Turing machine.

1h. Know the closure properties of regular languages and context-free languages.


Level 2 outcomes are those in which the student can apply the material in familiar situations, e. g., can work a problem of familiar structure with minor changes in the details.


2a. Convert a non-deterministic FA (resp. transition graph) into an equivalent deterministic FA, to convert a transition graph or NFA into an equivalent regular expression, and to convert a regular expression into an equivalent FA.

2b. Construct a regular expression (resp. a context-free grammar) for a regular language (resp. context-free language).

2c. Convert a context-free grammar into an equivalent pushdown automaton.2d. Give a context-free grammar for a given regular language and be able to convert a right linear

grammar into a transition graph.2e. Convert a multi-tape Turing machine into a Turing machine and a non-deterministic Turing

machine into a deterministic Turing machine.2f. Build a Turing machine for a language and a Turing machine that performs a simple

computation, e.g., adding two integers.2g. Use the pumping lemma for regular languages (resp. context-free languages) or closure

properties for regular languages (resp. context-free languages) to show that a language is not regular (resp. not context-free).

2h. Apply bottom-up and top-down parsing.




3a. Compare regular, context-free, recursive, recursively enumerable languages.3b. Assess the implications of Church-Turing-Markov’s thesis.3c. Determine problems for which an algorithm exists, and problems for which there are no

algorithms (non- recursive, non-recursively enumerable languages) and understand the implications of such results.

3d. Evaluate the complexity class of a problem (P, NP, NP-complete, NP-Hard).3e. Verify the diagonalization process to show that the Halting problem is not recursive and to

show the existence of languages that are not recursively enumerable.3f. Extend and apply results seen in class (for instance, “a language is recursive if and only if it

is recursively enumerable and co-Turing recognizable”).



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-7 Apply problem-solving techniques to solve real-world problems.2-3 Formulate and pose incisive, technical questions.




Regular languages, finite automata, non deterministic FA, transition graphs Regular expressions, Kleene’s theorem Context-free languages, pushdown automata, equivalence Parsing, normal forms, ambiguity Pumping lemmas and closure properties Turing machines and other equivalent models Decidable languages, recognizable languages, Chomsky hierarchy Introduction to computability, halting problem Introduction to complexity and complexity classes, P, NP, NP complete, NP hard

COURSE DESCRIPTION


Title

Design and Implementation of Programming Languages

Semester

hours


Yoonsik Cheon


Design features of modern programming languages including flow control mechanism and data structures; techniques for implementation of these features.

Textbook

R. W. Sebesta, Concepts of Programming Languages, 7th ed., Boston: Addison-Wesley, 2005.

References

Supplemental readings will be taken from the Web or hard copies will be handed out in class.

Course Outcomes




1a. Explain the broad outlines and major names in the history of development of programming languages.

1b. Recognize major programming languages.1c. Explain the stages of programming language interpretation and compilation.1d. Understand context-free grammars and (E)BNF notations.1e. Explain operational semantics, axiomatic semantics, and denotational semantics as methods

of expressing programming language semantics.1f. Explain design concepts, design alternatives and trade-offs, and implementation

considerations for scope, binding, data types, expressions, control structures, subprograms, abstract data types, objects, concurrency structures, and exception handling in modern programming languages.




2a. Show the syntax of a small context-free grammar in BNF and EBNF.2b. Use attribute grammars to describe the static semantics of small programming languages.2c. Implement dynamic semantics of small subsets of programming languages, e.g., expressions

and control structures.2d. Compare different approaches to naming, storage bindings, typing, scope, and data types.2e. Select and apply appropriate expressions and control structures for a given programming

task.2f. Analyze design dimensions of subprograms, including parameter passing methods,

subprograms as parameters, and overload subprograms.2g. Analyze and evaluate data and control abstractions of programming languages.




3a. Evaluate modern, representative programming languages critically.3b. Choose a suitable programming paradigm and language for a given problem or domain.3c. Design a small, domain-specific programming language, e.g., a test script language, by

defining its formal syntax and semantics.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.




This course presents concepts and examples of programming languages with the goal of acquiring the tools necessary for critical evaluation and rapid mastery of programming languages and constructs. The course attempts to balance theory and hands-on experience.


Survey of the constructs and capabilities typically found in modern programming languages

Design trade-offs and implementation considerations Several programming paradigms (object-oriented, aspect-oriented, functional, logic, and

web-scripting) Detailed study of representative languages

COURSE DESCRIPTION


Title

Computer Graphics

(Technical Elective)

Semester

hours

45 Course Coordinator

Luc Longpre


An introduction to representation and display of graphical information including line, character, and curve generation. Emphasis on two-dimensional techniques.

Textbook

D. Hearn and M. P. Baker, Computer Graphics with OpenGL, Upper Saddle River, N. J.: Prentice Hall, 2004.

References

NA




1a. Describe graphical representation of data. 1b. Explain the complexity of graphical computation. 1c. Recognize the need of efficient algorithms.1d. Discuss the rapidly expanding applications of computer graphics.1e. Identify hardware support for graphical processes.




2a. Apply mathematical concepts to graphical applications.

2b. Apply efficient algorithms to a specific problem.2c. Use intrinsic graphical functions to solve a problem.




3a. Evaluate where graphical representation would be advantageous.3b. Develop the code to produce a graphical representation.3c. Incorporate the tools provided by a high level graphics package.


The course outcomes for CS 3370 contribute to the following program outcomes:

1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-7 Apply problem-solving techniques to solve real-world problems.

COURSE DESCRIPTION


Title

Computer Architecture I: Basic Computer Organization and Design

Semester

Hours

45hrs + Labs

Course Coordinator

Pat Teller


Compile and assembly processes; machine organization; fetch/decode/execute process; symbolic coding of instructions and data, including instruction types, formats, and addressing modes; implementation of data and control structures, subroutines, and linkage; and input/output handling at the assembly level, including memory-mapped I/O and interrupt and exception handling.

Textbook

H. W. Huang, MC68HC11 An Introduction: Software and Hardware Interfacing, 2nd ed., Clifton Park, N. Y.: Thomson Delmar Learning, Inc., 2003. ISBN 0-76681600-1

S. Roach, P. Teller, A. Sainz, M. Nieto, and M. Maxwell, Laboratory Manual Computer Science 3432: Computer Architecture I, UTEP, 2004. (UTEP Copy Center, Library Basement)

References

The following literature has been donated by Motorola, Inc.:

M68HC11E Series Programming Reference Guide.

Course Outcomes




1a. Understand a symbol table. 1b. Discuss the functions of a compiler.1c. Describe fixed and floating-point numbers.1d. Define RAM, ROM, EPROM.1e. Explain disk architecture/access time (seek time, rotational latency, transfer time).




2a. Examine the functions of assembler, linker and loader, relocatable code, and assembler directives.

2b. Analyze the fetch/decode/execute cycle, program counter, “machine state, instruction execution time, i.e., why some instructions take longer to execute than others (w.r.t. memory access)”, effective address calculation.

2c. Demonstrate finite state machines.2d. Use registers and memory (stored program concept), addressing bytes and words in memory.2e. Apply interrupt handling.2f. Manipulate stack, stack pointer, frame, frame pointer.2g. Distinguish interrupt-driven vs. memory-mapped I/O.2h. Use data representation and number bases (powers of 2, binary, decimal, and hexadecimal

representation). 2i. Use representation of nonnumeric data.2j. Convert data from one representation to another.2k. Differentiate least- and most- significant bits.2l. Examine signed and unsigned numbers, sign extension, overflow detection, underflow

detection, one’s complement, two’s complement, and sign magnitude representation.2m.Analyze basic machine organization, control unit and function.2n. Compare a two-pass assembler and backpatching.2o. Utilize instruction set architecture, i.e., opcodes, operands, instruction formats and types

(data manipulation, control, I/O).2p. Investigate the condition code register and its function.2q. Arrange data, text, and stack segments. 2r. Analyze subroutines, caller, callee, return address, parameter passing techniques.




3a. Produce assembly/machine language programming--assembly language, machine language (assembly/disassembly)--pseudo-assembler templates for high-level programming constructs such as if-then-else, while loop, repeat-until loop, do loop, case statement.

3b. Construct examples using the following addressing modes: register, base or displacement, immediate, PC-relative, pseudodirect.

3c. Prepare a program design, implementation (modularization), testing, documentation.3d. Develop problem solving techniques.3e. Compose precise written reports and oral presentations.3f. Create simulations.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.2-1 Present technical information orally.2-2 Write a professional technical report.2-3 Formulate and pose incisive, technical questions.




Introduction to basic machine organization, stored program concept, program counter, fetch/decode execute process, machine state, RAM, ROM, EPROM, registers, machine code, assembly code

Functions of assembler, linker, and loader; the assembly process, symbol table, and assembler directives; relocatable code; instruction set architecture; instruction formats; addressing modes; effective address calculation; overflow and underflow

Data manipulation, data movement, control-flow, condition-code register, translation of high-level programming language constructs to assembly language constructs, representation of numeric and non-numeric data

Data/text/stack segments, subroutine linkage, calculation of execution time and how it is linked to cycles per instruction

Input/output including memory-mapped I/O, interrupt, and exception handling Program design, implementation (modularization), testing, debugging, documentation,

and introduction to basic concepts of software engineering

COURSE DESCRIPTION


Title

Software Engineering: Requirements Engineering

Semester

Hours


Ann Q. Gates and Steve Roach


Methodologies, approaches, and techniques associated with software requirements analysis and definition; process for defining requirements of a system including feasibility study, requirements elicitation, formal specification, modeling, validation, verification, and documentation; other topics include cooperative teamwork and project management; first semester of a two-semester capstone project in which students work with a customer.

Textbook

D. Ghezzi, M. Jazayeri, and D. Mandrioli, Fundamentals of Software Engineering, 2nd ed., Upper Saddle River, N. J.: Prentice Hall, 2003. ISBN 0-13-305699-6.

R. Pressman, Software Engineering. A Practitioner Approach, 6th ed., New York: McGraw-Hill, 2005.

References

NA

Course Outcomes




1a. Identify major issues related to developing a human-computer interface.1b. Understand basic societal issues regarding software development. 1c. Know the purpose of audits, inspections, and walk-throughs.1d. Define basic software engineering concepts and principles (abstraction, cohesion and coupling,

decomposition, encapsulation, information hiding, modularity, partitioning, stepwise refinement, and separation of concerns).

1e. Define quality attributes such as availability, correctness, efficiency, interoperability, maintainability, portability, reliability, reusability, security, simplicity, testability, and usability.

1f. State the main features of process improvement models, e.g., CMM, ISO, PSP, QPI, TPI, CQI, Plan-Do-Check.

1g. Discuss in general terms the main factors in cost estimation.1h. Discuss basic concepts in project management and team, including elements of cooperative teams.1i. Describe basic concepts in requirements engineering.1j. Define the basic elements and purpose of modeling.




2a. Determine which life cycle model to use by analyzing different scenarios.2b. Apply techniques for eliciting requirements, including conducting interviews and developing a

throw-away prototype.2c. Analyze requirements to determine if they meet the attributes of well-written requirements.2d. Differentiate between audits, inspections, and walk-throughs.2e. Conduct a technical review including inspections, walkthroughs and audits.2f. Detect risks in software development and project management.2g. Apply project management techniques.2h. Differentiate among modeling techniques. 2i. Demonstrate skills in cooperative working groups and apply conflict resolution techniques in order to

achieve group goals.2j. Examine potentially negative technical, ethical, or legal implications of software engineering projects

on customers or others involved.2k. Exhibit responsible attitudes and work habits as individuals and groups, in accordance with

professional software engineering codes of ethics. 2l. Relate the importance of professional societies.




3a. Construct a feasibility report.3b. Construct a software requirements specification.3c. Analyze and model aspects of a problem by applying object modeling.3d. Analyze and model aspects of a problem by applying data-flow diagrams.3e. Analyze and model aspects of a problem by applying state transition diagram.3f. Develop use cases and scenarios. 3g. Assemble and present technical work orally. 3h. Compose technical documents that are grammatically correct and technically sound.3i. Develop effective techniques for collaboration and problem-solving within groups in order to create

finished products of high quality.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.2-1 Present technical information orally.2-2 Write a professional technical report.3-1 Participate as a productive member of a team.3-2 Solve common problems in team dynamics.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.4-2 Apply the insights embodied in professional codes of ethics.5-2 Describe the role of professional societies.


This class has to be taken two semesters before graduation.


The goal of this course is to provide computer science students with software requirements and design techniques that result in the development of maintainable and reliable software that meets the customer’s needs. In practical terms, this and CS4311 are meant to provide students with an approximation of a real-world experience of software development.

Major topics include: Introduction to Software Engineering Personality Workshop Software Qualities Software Lifecycle Cooperative Teams Requirement Analysis Use Cases Feasibility Study OMT Process Models

COURSE DESCRIPTION

Dept. Number CS4311 Course Title Design and Implementation

Semester Hours 45 hrs. Course Coordinator Ann Q. Gates and Steve Roach


Methodologies, approaches, and techniques associated with software design, implementation, and testing of a software system; other topics include cooperative teamwork, project management, and documentation; second semester of a two-semester capstone project in which students design and implement a real-world application specified in CS 4310.

Textbook

D. Ghezzi, M. Jazayeri, and D. Mandrioli, Fundamentals of Software Engineering, 2nd ed., Upper Saddle River, N. J.: Prentice Hall, 2003. ISBN 0-13-305699-6.

R. Pressman, Software Engineering. A Practitioner Approach, 6th ed., New York: McGraw-Hill, 2005.

References

NA

Course Outcomes

Level 1: Knowledge and ComprehensionLevel 1 outcomes are those in which the student has been exposed to the terms and concepts at a basic level and can supply basic definitions. The material has been presented only at a superficial level.


1a. Define and relate basic software engineering concepts and principles (abstraction, cohesion and coupling, decomposition, encapsulation, information hiding, modularity, partitioning, stepwise refinement, and separation of concerns)

1b. Express the need to conduct audits, inspections, and walkthroughs.1c. Describe different categories of test coverage of code.1d. Describe different test levels (unit, integration, system, and acceptance). 1e. Define quality attributes such as availability, correctness, efficiency, interoperability,

maintainability, portability, reliability, reusability, security, simplicity, testability, and usability.

1f. Describe design approaches other than responsibility-driven object-oriented design.1g. State the main features of PSP.1h. Relate the main factors in cost estimation.1i. Discuss different approaches to process and product measures.1j. Discuss the issues related to maintenance.1k. Discuss different software architectural styles such as blackboard, event systems, layered

system, pipe and filters.1l. Recognize the term “software architecture patterns.”1m.Discuss the main components of the Software Engineering Code of Ethics.1n. Discuss basic concepts in project management and team, including elements of cooperative

teams.

Level 2: Application and AnalysisLevel 2 outcomes are those in which the student can apply the material in familiar situations, e.g., can work a problem of familiar structure with minor changes in the details.


2a. Differentiate between audits, inspections, and walk-throughs.2b. Apply different diagramming techniques for an architectural design, including class

diagrams, CRC cards, module diagrams, structure charts, and subsystem diagrams.2c. Apply different diagramming techniques for producing a detailed design of a system,

including collaboration diagrams, decision tables and diagrams.2d. Relate general strategies for creating a design of a system.2e. Distinguish between the different levels of cohesion and coupling.2f. Apply project management techniques.2g. Use software development and maintenance tools (creation and editing of software

documents), GUI generators, comprehension tools, supporting activities tools (configuration management tools), and verification and validation tools.

2h. Demonstrate skills in cooperative working groups and apply conflict resolution techniques in order to achieve group goals.

2i. Examine potentially negative technical, ethical, or legal implications of software engineering projects on customers or others involved.

2j. Exhibit responsible attitudes and work habits as individuals and groups, in accordance with professional software engineering codes of ethics.

2k. Relate the importance of professional societies.

Level 3: Synthesis and EvaluationLevel 3 outcomes are those in which the student can apply the material in new situations. This is the highest level of mastery.


3a. Conduct a technical review.3b. Implement a configuration management plan and versioning control.3c. Construct database tables.3d. Create an architectural design and detailed design for a large system.3e. Develop a design that anticipates change.3f. Construct software from a software design.3g. Develop white-box and black-box test cases.3h. Conduct unit and integration testing.3i. Develop a test plan for a large system.3j. Assemble and present technical work orally. 3k. Compose technical documents that are grammatically correct and technically sound.3l. Develop effective techniques for collaboration and problem-solving within groups in order to

create finished products of high quality.


As shown in Table 5b, the course outcomes for CS 4311 contribute to the following program outcomes:

1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-7 Apply problem-solving techniques to solve real-world problems.2-1 Present technical information orally.2-2 Write a professional technical report.3-1 Participate as a productive member of a team.3-2 Solve common problems in team dynamics.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.4-2 Apply the insights embodied in professional codes of ethics.5-2 Describe the role of professional societies.




The goal of this course is to provide students with design techniques that result in the development of maintainable and reliable software that meets the customer’s needs. CS4311 provides students with an approximation of a real-world experience of software development.


Professional and ethical responsibilities Configuration management Software design analysis techniques High-level software design Software design specification Software implementation Software validation and verification Maintenance approaches and techniques Teams

COURSE DESCRIPTION

Dept. Number CS4316 Course Title CS4316- Computer Networks (Technical Elective)

Semester Hours 45 hrs. Course Coordinator Rolfe Sassenfeld


Introduction to data communications. Covered topics include: data transmission, link control, encoding, multiplexing, switching, network topologies, internetworking, address resolution, protocol layering, routing methods, data security, and distributed systems.

Textbook

D. Comer, Computer Networks and Internets, 4th ed., Upper Saddle River: Prentice Hall, 2004.

References

NA

Course Outcomes




1a. Recognize the limits of current network technology.1b. Discuss future network technology.1c. Explain the theory of universal service.1d. Describe probabilistic models of computer networking.




2a. Analyze Local Area Network design. 2b. Analyze Wide Area Network design.2c. Utilize protocol configuration.2d. Compare network addressing schemes.2e. Detect packet transmission.

2f. Examine frame structure.2g. Apply the client/server model.




3a. Design Local Area Network topology.3b. Design Wide Area Network topology.3c. Arrange network hardware components.3d. Compose a layered approach to networking.3e. Determine components and design of the physical layer.3f. Plan and setup Transport Control Protocol/Internet Protocol.3g. Integrate internetworking hardware and software.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-7 Apply problem-solving techniques to solve real-world problems.3-1 Participate as a productive member of a team.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.




Networking and network characteristics Transmission media Local asynchronous communication and long distance communication Packets, frames, and error detection LAN technology and network topology Hardware addressing and frame identification Physical topology, LAN wiring, and extended LANs Long distance digital technology WAN technology and routing Protocols and layering Internetworking, including TCP and IP

COURSE DESCRIPTION


Title

Artificial Intelligence


Semester

hours

45 hrs Course Coordinator Martine Ceberio


Introduction to basic concepts and techniques of artificial intelligence including knowledge representation, search strategies, symbolic logic, expert systems, and applications.

Textbook

S. Russell and P. Norvig, Artificial Intelligence: A Modern Approach, 2nd ed., Upper Saddle River, N. J.: Prentice Hall, 2003.

References

NA

Course Outcomes




1a. Understand what AI is: the main trends and corresponding problems tackled in AI.1b. Know the challenges of designing intelligent programs.1c. Be familiar with key previous work in a broad range of artificial intelligence subareas.1d. Understand what agents are, and how they contribute to the development of solutions to AI

problems.1e. Understand the basic idea of uncertainty, and be able to perform qualitative and quantitative

uncertainty calculations using simple Bayesian algorithms and belief networks.1f. Be familiar with the design of Knowledge Based Systems and production rules, through

study of classic examples.1g. Be familiar with problem-solving and the different solving approaches.


Level 2 outcomes are those in which the student can apply the material in familiar situations, e.g.,

can work a problem of familiar structure with minor changes in the details.


2a. Read and write (at least simple versions of) the major knowledge representation formalisms.2b. Explain, compare, and use the major search and planning techniques: a practical and

theoretical understanding of uninformed and informed search.2c. Apply AI techniques both in analytical and in programming contexts to solve problems, and

to communicate the results of such application.2d. Understand the limitations of AI, which problems are still hard, and why.




3a. Read research articles in AI (related or not to their project) and explain them in an abstracted way.

3b. Complete a team project.3c. Write a technical report for this project, and be able to present it in a clear and concise way.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-7 Apply problem-solving techniques to solve real-world problems.2-1 Present technical information orally.2-2 Write a professional technical report.3-2 Solve common problems in team dynamics.


CS2402 with a grade of “C” or better


Agents Knowledge representation and reasoning Problem-solving and game playing Planning and constraint solving Multi-agent systems Current research in AI

COURSE DESCRIPTION


Title

Database Management


Semester

hours

45hrs Course Coordinator Paulo Pinheiro da Silva


Introduction to data base concepts, hierarchical, network and relational data models, data description and query languages, file and index organization, and file security and integrity.

Textbook

T. M. Connolly and C. E. Begg, Database Systems: A Practical Approach to Design, Implementation, and Management, Boston: Addison-Wesley, 2005.

References

NA

Course Outcomes




1a. Describe relational databases, how they have been used in the past, and how they are used currently to implement solutions in technology.

1b. Define a database management system.1c. Describe the problems the second generation of databases solved.




2a. Differentiate between first generation and second generation database systems.2b. Identify different architectures where database systems are used (e.g., n-tier).

2c. Apply relational algebra and set theory that are supported in the relational model.2d. Use a relational query language (PL/SQL) and a RDBMS.2e. Administer a database. 2f. Normalize a database using the 1st, 2nd, and 3rd normal forms.2g. Apply techniques to optimize search/retrieval (indexes, and clusters).2h. Justify why one method is more useful than another, or be able to choose a method based on

specified characteristics.




3a. Design a relational database schema from a problem statement to conceptual/logical/physical database design.

3b. Design and code an interface that works with a normalized database, using the information read and discussed in class as well as the text.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-7 Apply problem-solving techniques to solve real-world problems.


CS2402 with a grade of “C” or better.


Introduction to Database Systems – Past and current Introduction to the Relational Model & Operations Introduction to Database Modeling

COURSE DESCRIPTION


Title

Compilers and Interpreters


Semester

hours

45 Course Coordinator Nigel Ward


The structure of compilers and interpreters: lexical syntax and semantic analysis, formal description of programming languages, parsing techniques, intermediate languages, optimization and code generation.

Textbook

D. A. Watt and D. F. Brown, Programming Language Processors in Java: Compilers and Interpreters, Upper Saddle River, N. J.: Prentice Hall, 2000.

References

http://www.dcs.gla.ac.uk/~daw/books/PLPJ/

Course Outcomes




1a. Understand the use of compilers and interpreters.




2a. Apply and improve programming skills.2b. Apply system integration skills.2c. Apply Unix skills2d. Apply knowledge from:

Data structures Programming language features

Assembly language and computer architecture Formal language and automata theory Operating systems




3a. Build compilers and interpreters by applying algorithms, data structures, and development techniques.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-7 Apply problem-solving techniques to solve real-world problems




Tokenizing/scanning, regular expressions, expression evaluation Grammars, driven parsing, AST construction Contextual analysis, type checking Interpretation Compiler parts, compiler organization, bootstrapping Code selection, code optimization, porting code Language specification, object-oriented languages Routines, control structures Storage allocation, heap management Unix

Dept., CS4365 Course Topics in Software Computing

Number Title


Semester

hours

45 Course Coordinator Vladik Kreinovich

COURSE DESCRIPTION


Introduction to basic concepts and techniques of soft computing, including neural, fuzzy, evolutionary, and interval computations, and their applications. This course may be repeated for credit when topic varies.

Textbook

None

References

NA

Course Outcomes




1a. Understand the need for intelligent and soft computing - NP-hardness of many practical problems, such as imprecise character of expert knowledge.

1b. Understand the main physical and engineering ideas behind a specific paradigm (such as neural, fuzzy, and evolutionary computations) or a specific application area (such as geoinformatics, bioinformatics).

1c. Know and understand the mathematics behind the studied paradigm and/or from the studied application area, e. g., for fuzzy computations, t-norms ("and" operations); t-conorms ("or" operations); and centroid defuzzification.

1d. Know the main algorithms developed within the studied paradigm or the studied application area, e. g., for fuzzy computations, algorithms behind fuzzy control; the problems solved by these algorithms; and the practical need to solve these problems.

1e. Recognize practical applications of intelligent and soft computing within the studied paradigm or the studied application area.

1f. Understand the limitations of the studied paradigm(s).1g. Have a general understanding of other paradigms and applications in the area of intelligent

and soft computing.




2a. Use the mathematics behind the studied paradigm or the studied application area, on simple examples.

2b. Trace the main algorithms developed within a studied paradigm or studied application area, on simple examples.

2c. Apply advanced state-of-the-art techniques developed within the studied paradigm or the studied application area to solve given problems.




3a. Design new algorithms, within the studied paradigm or application area, to solve problems similar to the ones studied in the class.

3b. Design programs which use techniques from the studied paradigm or the studied application area to solve reasonable size problems.

3c. Create a solution for a practice-oriented problem (ideally related to the student's area of research) by extracting an appropriate sub-problem from the general problem; selecting the most appropriate techniques from the studied paradigm or the studied application area; and actually applying these techniques.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.

1-7 Apply problem-solving techniques to solve real-world problems.2-1 Present technical information orally.2-2 Write a professional technical report.2-3 Formulate and pose incisive, technical questions.3-1 Participate as a productive member of a team.3-2 Solve common problems in team dynamics.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.4-2 Apply the insights embodied in professional codes of ethics.5-1 Describe the importance of and options available for continuing education. 5-2 Describe the role of professional societies.5-3 Articulate the benefits of graduate studies.


EE 3384 or STAT 3330, and MATH 4329.


The importance of estimating and processing uncertainty General techniques for estimating uncertainty of the results of data processing:

o Probabilistic techniqueso Interval techniqueso Monte-Carlo methodso Cauchy techniqueso Possibility of parallelization

Specific data processing techniques motivated by the presence of uncertainty:o Least Square Methodo Robust versionso General techniques for detecting linear and quadratic trendso Principal Component Analysis

Specific geospatial applications of estimating uncertainty, such as methods for detecting outliers and duplicates

How to determine geospatial characteristics based on measurement results ("inverse" problems) and specifics of uncertainty estimation for inverse problems:

o Description of the inverse problemo Known iterative algorithms for solving the problemo How to modify these algorithms depending on the data uncertainty and on the

constraintso Checkerboard and other techniques for estimating uncertainty in the solution of

the inverse problem Techniques for representing and processing expert uncertainty:

o Fuzzy techniqueso Data processing under fuzzy constraints

COURSE DESCRIPTION


Title

Computer Science Problems


Semester

hours

45 Course Coordinator N/A


Original investigation of special problems selected by the student in consultation with the instructor and with the permission of the Chairperson of the Computer Science Department. May be repeated for credit.

Textbook

Varies according to topic of investigation.

References

NA

Course Outcomes

Vary according to topic of investigation.


Varies according to topic of investigation.


Senior standing in Computer Science and department approval.


To be defined within a contract that binds the faculty and the student.

COURSE DESCRIPTION

Dept., Number CS4375* Course

Title

Theory of Operating Systems

(Technical Elective*)

Semester

hours

45 Course Coordinator Pat Teller

* CS 4375 now replaces CS 3335 Systems Programming as a required course.


Process and thread management, concurrency, memory management, processor scheduling, I/O management and disk scheduling, and file management.

Textbook

A. Tannenbaum, Modern Operating Systems, 2nd ed., Upper Saddle River, N. J.: Prentice Hall, 2001.

References

NA

Course Outcomes




1a. Explain the Windows NT operating system.1b. Explain the UNIX operating system.1c. Define distributed processing, client/server, and clusters.1d. Discuss distributed process management.




2a. Use file management (file organization, directories, and sharing), record blocking, and secondary storage management.

2b. Demonstrate multiprocessor and real-time scheduling.2c. Analyze I/O management and disk scheduling.




3a. Determine operating system objectives and functions.3b. Create process definition/description and control/management.3c. Construct threads, symmetric multiprocessing, and microkernels.3d. Develop mutual exclusion and synchronization (software and hardware approaches)—

semaphores, monitors, message passing, readers/writers problem.3e. Design for concurrency: deadlock and starvation—principles of deadlock, deadlock

prevention, avoidance, and detection.3f. Evaluate the “dining philosophers” problem. 3g. Incorporate memory management—paging, segmentation.3h. Incorporate virtual memory—hardware and control structures.3i. Produce process/thread scheduling algorithms.



1-1 Apply mathematical foundations, algorithmic principles, and computer science theory in the modeling and design of computer-based systems.1-2 Estimate the feasibility and effort required to build a particular computing system.1-3 Identify and specify requirements for computing systems by selecting appropriate modeling techniques and tools.1-4 Design, implement, and verify computing systems of varying complexity by using appropriate techniques and tools and by selecting appropriate design patterns, architectures, languages, and testing approaches.1-5 Evaluate a system with respect to criteria such as performance, complexity, correctness, and usability.1-6 Determine the impact of an architecture or platform on software design and implementation alternatives.1-7 Apply problem-solving techniques to solve real-world problems.4-1 Project the potential impacts of technical decisions on the individuals, organizations and external constituencies involved, and identify ethical and legal implications.




Processes and threads Synchronization Memory management

Input/Output File Systems Multimedia

COURSE DESCRIPTION


Title

Special Topics in Computer Science


Semester

Hours

Course Coordinator N/A


Selected topics of current interest in Computer Science. May be repeated for credit when topic varies. Examples of previous CS 4390 topics include: scientific and programming visualization, human-computer interaction, cryptography, software design, robotics, usability, and computer security.

Textbook

Varies according to course topic.

References

NA

Course Outcomes

Vary according to course topic.


Varies according to course topic.


Senior standing in Computer Science and department approval


Vary according to course topic.

robust.cs.utep.edurobust.cs.utep.edu/arch1/poster/all-cs-course-outcomes.doc · web viewapply graph...

Documents