haas/descriptions
... ...
@@ -0,0 +1,51 @@
1
+CSCS1460 C Programming
2
+======================
3
+C Programming for systems, commercial, and scientific applications. C
4
+vs. assembly language, data types, mathematical operations, operators,
5
+expressions, control flow, functions and program structure. Pointers
6
+and arrays, structures and unions, input/output.
7
+
8
+(3 cr. hrs.) (ASN) Prerequisite: CSCS 1240 or Instructor Consent.
9
+Lecture/laboratory.
10
+
11
+CSCS1730 UNIX/Linux Fundamentals
12
+================================
13
+UNIX/Linux Operating System basics. The primary emphasis of this course
14
+will utilize the command-line environment where students will demonstrate
15
+knowledge in the usage of the UNIX shell by moded editing, shell
16
+scripting, regular expressions, file manipulation, package management,
17
+and related topics.
18
+
19
+(4 cr. hrs.) (Fall, Spring). Prerequisite: CSCS1240 Structured Problem
20
+Solving (or be taking), or Instructor Consent.
21
+
22
+CSCS2430 Digital Logic
23
+======================
24
+Logic gates, flip-flops, circuit diagrams of different types of registers
25
+and counters, decoders, encoders, multiplexers, demultiplexers, adders,
26
+and characteristics of Asynchronous and Synchronous transmission.
27
+
28
+Prerequisite: CSCS1240 and MATH 1015, or instructor consent
29
+
30
+CSCS2460 Object-Oriented Programming using C++
31
+==============================================
32
+Provides a working knowledge of object-oriented programming using the
33
+C++ language. Extensive hands-on program development. Includes basic
34
+concepts of object- oriented programming, input/output, data types
35
+and operators, program control, object-oriented constructs, predefined
36
+classes, operations on objects, inheritance, polymorphism and virtual
37
+functions, templates, construction and use of libraries in C++.
38
+
39
+Prerequisite: CSCS1460 or instructor consent.
40
+
41
+CSCS2700 Data Communications
42
+============================
43
+Networks and communication techniques with computers or peripheral
44
+devices. Includes communications links and equipment, coding of
45
+information, line controls, protocols, multiplexing, socket programming,
46
+error correction algorithms, data transmission, and local area networks.
47
+Emphasis on modern internet protocols such as TCP/IP, including the
48
+application, transport, network, and link layers.
49
+
50
+(3 cr. hrs.) (Fall). Prerequisite: CSNT 1200 and (CSCS 1320 or CSCS
51
+2420), or instructor consent.
haas/objectives
... ...
@@ -0,0 +1,298 @@
1
+CSCS1320 C/C++ Programming
2
+==========================
3
+Upon completion of this course, students will be able to:
4
+
5
+1. Implement functional programs using basic syntax, including variables,
6
+loops, and conditional logic, that satisfy automated test requirements.
7
+
8
+2. Define the relationship between a variable’s value and its memory
9
+address using basic pointer syntax (the address-of and dereference
10
+operators).
11
+
12
+3. Recognize how data is represented and stored in memory, including the
13
+size and limits of standard primitive types.
14
+
15
+4. Label data structures as either scalar (single-value) or composite
16
+(multi-value) based on their declaration.
17
+
18
+5. Distinguish between collections of the same data type (arrays) and
19
+collections of differing data types (structures) within a code snippet.
20
+
21
+6. Construct modular code by defining functions and utilizing different
22
+methods of passing data into them.
23
+
24
+7. Select the most appropriate control structure or data type to solve a
25
+specific, predefined logical problem.
26
+
27
+8. Utilize built-in language libraries to perform standard input/output
28
+and common computational tasks.
29
+
30
+CSCS1460 C Programming
31
+======================
32
+Upon completion of this course, students will be able to:
33
+
34
+1. Implement programs using C syntax, including standard data types,
35
+arithmetic operators, and control flow structures such as loops and
36
+conditionals.
37
+
38
+2. Determine the memory address of a variable and the value it points to
39
+using basic pointer operators.
40
+
41
+3. Identify the memory requirements and storage limits of standard
42
+primitive data types.
43
+
44
+4. Classify variables as scalar types or composite types based on their
45
+declaration in source code.
46
+
47
+5. Differentiate between homogeneous data structures (arrays) and
48
+heterogeneous data structures (structs) in terms of memory layout and
49
+access.
50
+
51
+6. Construct modular programs by defining C functions and applying
52
+parameter passing by value and by address.
53
+
54
+7. Select the most efficient C control structure or data organization to
55
+meet a specific algorithmic requirement.
56
+
57
+8. Utilize built-in language functions to handle standard input, output,
58
+and basic data manipulation.
59
+
60
+CSCS1730 UNIX/Linux Fundamentals
61
+================================
62
+Upon completion of this course, students will be able to:
63
+
64
+1. Analyze the system hierarchy and environment variables to effectively
65
+organize and manage digital resources.
66
+
67
+2. Evaluate system manual pages and technical documentation to
68
+independently resolve syntax challenges and discover advanced utility
69
+features.
70
+
71
+3. Construct functional shell scripts that utilize conditional logic,
72
+iterative loops, and variables to automate repetitive tasks.
73
+
74
+4. Synthesize the "UNIX Philosophy" by linking discrete, single-purpose
75
+utilities through input/output streams to solve complex problems.
76
+
77
+5. Implement sophisticated pattern-matching techniques to search, filter,
78
+and transform text-based information within the command-line interface.
79
+
80
+6. Deconstruct multifaceted technical requirements into a logical
81
+sequence of smaller, programmable steps.
82
+
83
+7. Design reliable automation that incorporates error checking and input
84
+validation to ensure consistent execution.
85
+
86
+8. Apply Open Source principles by producing well-documented and
87
+maintainable code that adheres to collaborative community standards.
88
+
89
+CSCS2320 Data Structures
90
+========================
91
+Upon successful completion of this course, students will be able to:
92
+
93
+1. Analyze the memory allocation strategies and internal representations
94
+of primitive and user-defined data structures within system memory.
95
+
96
+2. Implement fundamental data structures—including linked lists,
97
+stacks, queues, and trees—from first principles using pointer
98
+manipulation and dynamic memory management.
99
+
100
+3. Evaluate the performance of alternative data structure implementations
101
+using Big O notation to determine time and space complexity.
102
+
103
+4. Synthesize complex programs by integrating multiple data structures to
104
+solve multi-faceted computational problems.
105
+
106
+5. Compare and contrast the trade-offs between static and dynamic memory
107
+structures regarding flexibility, overhead, and access speed.
108
+
109
+6. Justify the selection of a specific data structure based on the unique
110
+constraints and requirements of a given algorithmic challenge.
111
+
112
+7. Explain the practical applications of various data structures in
113
+software engineering, such as buffer management, recursion handling, and
114
+hierarchical data modeling.
115
+
116
+8. Debug and optimize data-intensive applications by tracing memory usage
117
+and resolving issues related to data persistence and integrity.
118
+
119
+CSCS2330 Discrete Structures
120
+============================
121
+Upon successful completion of this course, students will be able to:
122
+
123
+1. Simplify program control flow by applying Boolean algebraic identities
124
+to reduce the complexity of conditional logic.
125
+
126
+2. Implement low-level data manipulations using bitwise operations to
127
+manage binary states, masks, and flags.
128
+
129
+3. Apply recursive definitions and iterative logic to solve
130
+self-referential problems and manage hierarchical data processes.
131
+
132
+4. Utilize modular arithmetic and number theory concepts to develop
133
+efficient algorithms for data indexing and manipulation.
134
+
135
+5. Translate formal logical propositions into executable code to ensure
136
+rigorous validation of system constraints and user inputs.
137
+
138
+6. Evaluate algorithmic scaling and resource consumption by applying
139
+counting principles and growth rate analysis to code structures.
140
+
141
+7. Model discrete relationships between data elements using set theory to
142
+optimize searching, filtering, and organizational logic.
143
+
144
+8. Verify the correctness of software modules by constructing logical
145
+models that test all possible execution paths and state transitions.
146
+
147
+CSCS2430 Digital Logic
148
+======================
149
+Upon successful completion of this course, students will be able to:
150
+
151
+1. Analyze the relationship between different positional numbering
152
+systems—including binary, octal, and hexadecimal—to represent and
153
+manipulate data at the machine level.
154
+
155
+2. Evaluate Boolean functions and logic expressions to design optimized
156
+combinational circuits that minimize gate count and propagation delay.
157
+
158
+3. Construct complex functional units, such as adders, multiplexers, and
159
+decoders, by synthesizing fundamental logic gates (AND, OR, NOT, XOR).
160
+
161
+4. Model sequential logic components, including flip-flops and registers,
162
+to understand how data is persisted and synchronized across clock cycles.
163
+
164
+5. Implement finite state machines (FSMs) using digital logic components
165
+to control system behavior and manage hardware transitions.
166
+
167
+6. Translate high-level arithmetic operations into low-level binary
168
+circuits using two’s complement and carry-lookahead logic.
169
+
170
+7. Simulate the behavior of integrated circuits and digital systems
171
+to verify timing accuracy and logical consistency before physical
172
+deployment.
173
+
174
+8. Design programmable logic structures that bridge the gap between raw
175
+electronic hardware and software-defined instruction sets.
176
+
177
+CSCS2460 Object-Oriented Programming using C++
178
+==============================================
179
+Upon successful completion of this course, students will be able to:
180
+
181
+1. Analyze the core principles of the object-oriented paradigm,
182
+specifically encapsulation, data hiding, inheritance, and polymorphism,
183
+to manage software complexity.
184
+
185
+2. Design modular software systems by defining custom classes that
186
+represent real-world entities and their associated behaviors.
187
+
188
+3. Implement robust objects by developing constructors, destructors, and
189
+member functions to manage resource allocation and object lifecycle.
190
+
191
+4. Apply operator and function overloading to create intuitive interfaces
192
+and extend the functionality of user-defined types.
193
+
194
+5. Develop hierarchical class structures using single and multiple
195
+inheritance to promote code reusability and maintainability.
196
+
197
+6. Utilize polymorphism and dynamic binding to create flexible,
198
+extensible code that can process diverse object types through a unified
199
+interface.
200
+
201
+7. Leverage predefined standard libraries and container classes to solve
202
+complex computational problems efficiently.
203
+
204
+8. Navigate and utilize a command-line environment to compile, debug, and
205
+manage multi-file software projects within a professional development
206
+workflow.
207
+
208
+CSCS2650 Computer Organization
209
+==============================
210
+Upon successful completion of this course, students will be able to:
211
+
212
+1. Analyze the fundamental organization of a computer system, including
213
+the functional relationships between the CPU, memory hierarchy, and I/O
214
+subsystems.
215
+
216
+2. Evaluate the impact of various number systems and data representations
217
+on computational precision and hardware efficiency.
218
+
219
+3. Translate high-level programming logic into assembly-level
220
+instructions to demonstrate an understanding of the underlying execution
221
+model.
222
+
223
+4. Implement algorithmic solutions using low-level programming
224
+techniques, focusing on the effective use of processor registers and
225
+memory addressing modes.
226
+
227
+5. Apply stack and branching logic to develop structured, modular code at
228
+the machine level.
229
+
230
+6. Examine the interface between application software and the operating
231
+system by executing and managing direct system calls.
232
+
233
+7. Deconstruct the role of standard runtime libraries in abstracting
234
+hardware complexities and facilitating system-level services.
235
+
236
+8. Appraise how low-level architectural constraints and instruction set
237
+design influence the performance and optimization of high-level software.
238
+
239
+CSCS2700 Data Communications
240
+============================
241
+
242
+1. Analyze the fundamental principles of network I/O and their impact on
243
+data communication efficiency and system performance.
244
+
245
+2. Evaluate the trade-offs between various inter-process communication
246
+(IPC) mechanisms for local and distributed systems.
247
+
248
+3. Design and implement robust application-layer protocols for reliable
249
+data exchange across heterogeneous networks.
250
+
251
+4. Implement concurrent programming models to manage multiple
252
+simultaneous communication streams and shared resources.
253
+
254
+5. Synthesize operating system services with application logic to
255
+facilitate seamless network integration.
256
+
257
+6. Apply synchronization primitives to ensure data integrity and prevent
258
+race conditions in networked environments.
259
+
260
+7. Architect scalable client-server or peer-to-peer systems using
261
+standard abstraction layers.
262
+
263
+8. Appraise the security and reliability implications of different
264
+network communication strategies.
265
+
266
+CSCS2730 System Programming
267
+===========================
268
+Upon successful completion of this course, students will be able to:
269
+
270
+1. Analyze the mechanics of low-level file I/O and buffered streams to
271
+implement efficient, non-redundant data processing routines.
272
+
273
+2. Apply Operating System APIs and system calls to manage hardware
274
+resources and mediate interactions between user-space applications and
275
+the kernel.
276
+
277
+3. Evaluate various inter-process communication (IPC)
278
+mechanisms—including pipes, named pipes, and sockets—to determine the
279
+most effective strategy for data exchange in a distributed or local
280
+environment.
281
+
282
+4. Construct multi-process systems by implementing process creation,
283
+execution, and synchronization logic (e.g., using fork, exec, and wait).
284
+
285
+5. Develop robust event-driven programs capable of intercepting,
286
+handling, and managing asynchronous signals to ensure process stability.
287
+
288
+6. Implement concurrent programming models using threads and
289
+synchronization primitives to maximize CPU utilization and manage shared
290
+resources without race conditions.
291
+
292
+7. Synthesize complex system architectures that integrate multiple
293
+OS-level resources (file systems, networking, and task scheduling) to
294
+solve data-intensive computational problems.
295
+
296
+8. Design collaborative software solutions that leverage modularity and
297
+resource sharing to optimize system-wide performance and scalability.
298
+