CS Curricula

Courses tagged with intro

COSC-105: Introduction to Computing and The Arts (1) intro

This introductory course explores computation as an artistic medium, with creative approaches to computer programming as the central theme. Through readings, viewing, group discussion, labs, projects, critiques and guest artist/researcher presentations, we examine a range of computational art practices, while developing a solid foundation in basic computer programming approaches and techniques. (Amherst)

COSC-111: Introduction to Computer Science I (1) intro

This course introduces ideas and techniques that are fundamental to computer science. The course emphasizes procedural abstraction, algorithmic methods, and structured design techniques. Students will gain a working knowledge of a block-structured programming language and will use the language to solve a variety of problems illustrating ideas in computer science. A selection of other elementary topics will be presented. A laboratory section will meet once a week to give students practice with programming constructs. Two class hours and one one-hour laboratory per week. (Amherst)

COSC-111L: Introduction to Computer Science Lab (1) intro

Lab section for COSC 111 (Amherst)

COSC-112: Introduction to Computer Science II (1) intro

A continuation of COSC 111. This course will emphasize more complicated problems and their algorithmic solutions. The object-oriented programming paradigm will be discussed in detail, including data abstraction, inheritance, and polymorphism. Other topics will include stacks, queues, linked lists, programming for graphical user interfaces, and basic topics in probability. A laboratory section will meet once a week to give students practice with programming constructs. (Amherst)

COSC-112L: Introduction to Computer Science II Lab (1) intro

COSC 112 Lab Section (Amherst)

COSC-211: Data Structures (1) intro

A fundamental problem in computer science is that of organizing data so that it can be used effectively. This course introduces basic data structures and their applications. Major themes are the importance of abstraction in program design and the separation of specification and implementation. Program correctness and algorithm complexity are also considered. Data structures for lists, stacks, queues, dictionaries, sets, and graphs are discussed. This course will provide advanced programming experience. (Amherst)

CSE 100: Principles of Programming with C++ (3) intro

Principles of problem solving using C++, algorithm design, structured programming, fundamental algorithms and techniques, and computer systems concepts. Social and ethical responsibility. (ASU)

CPI 101: Introduction to Informatics (3) intro

Concepts, tools, techniques, and applications of informatics. Includes overview of programming, data management, visualization, modeling, and social implications. (ASU)

CSE 101: Introduction to Computer Science and Programming for Non-Computer Science Majors (3) intro

Introduces students to the fundamental concepts of computer science (CS) and programming. Computers are a ubiquitous part of our lives every day. A foundational knowledge of how computers operate, what they are capable of and how we can leverage these capabilities confers powerful advantages for anyone who uses computers in their lives and careers. Delivers the knowledge and skill necessary to realize these advantages. Also provides a solid foundation on which students can continue to build by taking more advanced CS courses or self-study using many freely available resources. (ASU)

CSE 110: Principles of Programming (3) intro

Concepts of problem solving using an object-oriented programming language, algorithm design, structured programming, fundamental algorithms and techniques. (ASU)

CSE 120: Digital Design Fundamentals (3) intro

Number systems, conversion methods, binary and complement arithmetic, Boolean algebra, circuit minimization, ROMs, PLAs, flipflops, synchronous sequential circuits. (ASU)

CSE 205: Object-Oriented Programming and Data Structures (3) intro

Problem solving by programming with an object-oriented programming language. Introduces data structures. Overview of computer science topics. (ASU)

CSE 220: Programming for Computer Engineering (3) intro

Introduction to C/C++, systems programming, and concurrency. (ASU)

CPI 221: Advanced Object-Oriented Principles Using Java (3) intro

Advanced object-oriented programming using the Java language. Design concepts and problem solving. (ASU)

CSE 225: Introduction to Modern Computing Systems (3) intro

An overview of modern computing systems emphasizing the understanding of computer components, client-server architectures, cloud computing and intelligent systems. (ASU)

COMP 1200: Introduction To Computing For Engineers And Scientists (2) intro

Computer programming in a high-level language, with emphasis on use of the computer as a tool for engineering or science. (Auburn)

COMP 1201: Introduction To Computing Laboratory (1) intro

Laboratory activities focused on computer programming in a high-level language. (Auburn)

COMP 1210: Fundamentals Of Computing I (3) intro

Introduction to the fundamental concepts of programming from an object-oriented perspective. Emphasis on good software engineering principles and development of the fundamental programming skills in the context of a language that supports the object-oriented paradigm. (Auburn)

COMP 1220: Introduction To Computing with Python (2) intro

Computational problem-solving using Python, with emphasis on developing programs from specifications, verification and testing, and engineering applications. (Auburn)

COMP 1230: Introduction To Computing with Matlab (2) intro

Computational problem-solving using MATLAB, with emphasis on developing programs from specifications, verification and testing, and engineering applications. (Auburn)

COMP 2210: Fundamentals Of Computing II (4) intro

Software development in the context of collections (e.g., lists, trees, graphs, hashtables). Communication, teamwork, and a design experience are integral course experience. (Auburn)

COMP 3000: Object-Oriented Programming For Engineers And Scientists (3) intro

Fundamentals of object-oriented design and programming principles; data abstraction, identifying objects, problem decomposition, design and implementation of classes. (Auburn)

CSCI 1200: Introduction to Computers and Programming (3) intro

This course emphasizes analytical thinking and teaches problem solving through an introduction to basic programming structures. It covers design of well-structured algorithms using appropriate logic structures with simple data types and data structures. (Augusta)

CSCI 1210: Introduction to Java Programming (3) intro

An introduction to the basic concepts, logic, and syntax of the Java programming language. The use of elementary programming techniques and algorithms is presented. Topics include: arithmetic operations, input/output, data types, variables, selection and control statements, applications, applets, and event-driven programming. (Augusta)

CSCI 1301: Principles of Computer Programming I (4) intro

A rigorous study of the principles of computer programming with emphasis on problem solving methods which result in correct, well-structured programs. Other topics: an introduction to data representation, data types and control structures, functions, and structured data types. (Augusta)

CSCI 1302: Principles of Computer Programming II (3) intro

A continuation of problem solving methods and algorithm development. Topics include data structures and their implementation, algorithm development and programming. The emphasis is on program development and style. (Augusta)

CSCI 2120: Introduction to C# Programming (3) intro

This course introduces the fundamental principles of object-oriented programming using C#. The focus is on applications development using object-oriented design and implementation techniques. Topics include: objects, classes, inheritance, interfaces, GUI components, layout managers, events, multimedia, exception handling, and I/O files. (Augusta)

AIST 2120: Principles of Scripting and Automation (3) intro

An intermediate programming course focused on solving and automating common information technology challenges using a contemporary scripting language. Topics include command line interfaces, scripted control structures, arrays and dictionaries, object-oriented design concepts, and text processing. (Augusta)

AIST 2220: Introduction to Web Development (3) intro

Students will be exposed to appropriate format and page layout, adding and manipulating visuals, images, and rich media, creating a navigation scheme and linking together multiple pages and sites, creating basic forms, building interactive features, and publishing/maintaining web sites. (Augusta)

AIST 3120: Applications Programming (3) intro

An intermediate course in programming which focuses on developing code and structures for multi-tier applied information system solutions. (Augusta)

CSCI 3400: Data Structures (3) intro

A study of the techniques for representation and manipulation of structured data within a digital computer. Programming assignments illustrating a variety of data structures. (Augusta)

CYBR 6250: Scripting and Automation for Cybersecurity (3) intro

This course provides students with the basic ability to create simple scripts/programs to automate and perform security operations, and to provide students with the skills necessary to implement algorithms using programming languages to solve problems. Special emphasis is placed on scripts related to attacking and defending, which includes basic security practices in developing scripts/programs. (Augusta)

CSI 1401: Introduction to Programming I (4) intro

An introduction to computer science for non-majors, emphasizing computational thinking, problem-solving, small-scale programming, and applications. This includes basic programming constructs such as data, variables, functions, conditionals, loops, lists, files, sets, dictionaries, object-oriented programming, and problem solving. Applications will include image processing, numerical computing, and graphics. (Baylor)

CSI 1402: Introduction to Programming II (4) intro

This includes more advanced programming concepts such as data structures, class objects, object oriented programming and algorithm analysis (Baylor)

CSI 1430: Introduction to Computer Science I with Laboratory (4) intro

Introduction to computers, problem solving and algorithm development. Design, code, debug and document programs using techniques of good programming style and C++ programming language. Laboratory experiments and examples will be used to illustrate and reinforce concepts taught in the lectures. (Baylor)

CSI 1440: Introduction to Computer Science II with Laboratory (4) intro

Continuation of CSI 1430. Introduction to basic aspects of arrays, pointers, classes, inheritance, polymorphism, virtual functions, linked lists, stacks, queues, and binary trees. (Baylor)

CSI 3334: Data Structures (3) intro

Software design and construction with abstract data types. Description, performance and use of commonly-used algorithms and data structures including lists, trees, and graphs. (Baylor)

CS 110: Programming Concepts and Applications (4) intro

An introductory course for students with little or no programming experience. Basic control flow, data types, simple data structures and functions using a scripting language. Developing code using an integrated environment. The basics of directories, files and file types, including text files. Simple examples of the applications enabled by a modern, platform-independent scripting language such as GUIs, event handling, and database access. This course is open to all students who have not taken any other CS courses (with the exception of CS 105) and under these conditions, can count as free-elective credit for CS majors. (Binghamton)

CS 120: Programming and Hardware Fundamentals (4) intro

Introduction to the C programming language, including local and global variables, basic control structures, function calls, pointers and the stack; use of command-line C development environments and development tools such as gdb and make; assembly language connection to higher-level C; building blocks of the Von Neumann machine (ALU, registers, control unit, RAM, decoders, program counters) and the underlying basic logic elements; simple non-pipelined processor architectures. Supervised laboratory work involves programming in C and low-level languages, interfacing with hardware, and the design and simulation of small circuits and simplified microprocessors. (Binghamton)

CS 210: Programming with Objects and Data Structures (4) intro

Assumes a foundation in procedural programming as covered in CS 110. Provides the foundations of software development using Java. Problem solving using object-oriented programming techniques is emphasized. Topics include primitive and reference data types, variables, expressions, assignment, functions/methods, parameters, selection, iteration, recursion, exception handling, generic linear data structures and maps, file types, file I/O, simple GUIs, programming to an interface, use of inheritance, design patterns, javadoc documentation, and introduction to Java threads. Required laboratory provides supervised problem solving, programming using the command line as well as Eclipse, Netbeans, or IntelliJ development environments, code backup in a version control repository, debugging and JUnit testing techniques. (Binghamton)

CS 440: Adv Topics - Obj Oriented Prog (4) intro

Object-oriented programming and its concomitant design patterns provide rich abstractions for program development. These programs will eventually execute on real hardware, however. This course will investigate advanced object-oriented techniques and how they interact with hardware and operating system issues. We will ground our topics in C++, but the goal of the course will be to develop understanding that can be applied across languages. We will examine different design techniques for things such as memory management, and explore how and why they differ in performance and robustness. We will also cover idioms such as "Resource Acquisition Is Initialization" (RAII) and how they can be used to provide robust resource management for exceptions (exception safety). We will also devote time to covering generic programming and related topics such as expression templates. This is a growing area that seeks to decouple algorithms and data structures through the use of templates and other meta-programming techniques. These techniques exploit the fact that the C++ template mechanism is a language-within-a-language that is executed at compile-time rather than run-time. Additional topics include dynamic linking for techniques such as "plug-ins", template instantiation mechanisms, template specialization, idioms for memory management, thread-safety issues, thread-safety, C++ reflection. (Binghamton)

CSCI1080: Principles of Computer Science (3) intro

This is an introductory course for students with little or no programming experience. It is intended principally for students who will not be CS majors or minors, but it will help prepare students for future computer science courses if they wish to continue, and will enable them to use programming to solve problems in their field of study. The course presents an overview of the history, great principles, and transformative applications of computer science, as well as a comprehensive introduction to programming. Students will start with visual coding and later be introduced to Python. The course is based on the 'learning by doing' approach where active participation and pair programming are pillars of the course. (Boston)

CSCI1090: Data Science Principles (3) intro

This course will provide students with an overview of the field of data science and its responsible uses, along with an introduction to programming in Python from a data science perspective. An emphasis will be placed on solving problems and applying data science principles to real-world datasets. For example, students will learn sorting algorithms that would be taught in a traditional introduction to programming class, but then will apply the algorithms to a data science problem (for example assessing the fairness of a loan scoring algorithm with respect to protected classes of individuals). Python programming topics will include data structures, functions, recursion, algorithms, exploratory data analysis, data processing and visualization. Students will engage through readings and in-class discussions on topics such as applications of data science for the common good, privacy in a digitally connected world, issues of representation and omission in data collection, biases inherent in constructing information infrastructures and classification schemes, and the impacts of algorithmic decision-making. (Boston)

CSCI1101: Computer Science I (3) intro

This course is an introduction to the art and science of computer programming and to some of the fundamental concepts of computer science. Students will write programs in the Python programming language. Good program design methodology will be stressed throughout. There will also be a study of some of the basic notions of computer science, including computer systems organization, files and some algorithms of fundamental importance. (Boston)

CSCI1102: Computer Science II (3) intro

In this course, the student will write programs that employ more sophisticated and efficient means of representing and manipulating information. Part of the course is devoted to a continued study of programming. The principal emphasis, however, is on the study of the fundamental data structures of computer science (lists, stacks, queues, trees, etc.). Both their abstract properties and their implementations in computer programs and the study of the fundamental algorithms for manipulating these structures. Students will use Java for programming. (Boston)

ADIT1985: Python (4) intro

This course is meant for any student interested in learning computer programming concepts with the Python programming language. We will cultivate our problem-solving abilities as we develop programs in Python. This course is suitable for students with little to no programming experience. The course will start with the basics as we discuss logical decisions and loops. Further, we will explore Python data structures such as tuples, sets, lists, and dictionaries. We will couple this knowledge to make our own classes as we learn about object-oriented programming. Throughout the semester we will discover and implement basic debugging techniques. By the end of this course, students will compose Python programs that solve problems on their own. (Boston)

ADIT1990: C++ (4) intro

An introduction to programming with C++. This course is meant for students with little or no programming experience. We will start with the basics of programming using the C++ programming language. C++ is the cornerstone programming language used to develop many of the fundamental applications we use on a daily basis. For example operating systems, web browsers and other programming languages such as Java, Python, and SQL are built with C++. We will use the low level nature of the C++ programming language to learn about the fundamental aspects of how a computer works. In this course we will develop basic command line applications, explore how data is stored in memory and how we may use logic to manipulate the data to produce different results. (Boston)

CSCI2227: Introduction to Scientific Computation (3) intro

This is an introductory course in computer programming for students interested in numerical and scientific computation. Emphasis will be placed on problems drawn from the sciences. Many mathematical models of the behavior of complex natural systems have no closed-form solution, and computational modeling is needed for data exploration and to obtain approximate solutions. The course discusses different models and approximation methods, how to implement them as computer programs, and the factors that influence approximation quality. Topics include computer representation of floating-point numbers and data, computer program design and control flow, data visualization, nonlinear equations, systems of linear equations and least-squares, and Fourier analysis, with additional topics as time allows. Students will write programs in the Python programming language, primarily. (Boston)

CS 111: Introduction to Computer Science 1 (4) intro

The first course for computer science majors and anyone seeking a rigorous introduction. Develops computational problem-solving skills by programming in the Python language, and exposes students to variety of other topics from computer science and its applications. Carries MCS divisional credit in CAS. (BU)

CS 112: Introduction to Computer Science 2 (4) intro

Covers advanced programming techniques and data structures. Topics include recursion, algorithm analysis, linked lists, stacks, queues, trees, graphs, tables, searching, and sorting. Carries MCS divisional credit in CAS. (BU)

COSI 10a: Introduction to Problem Solving in Python (4) intro

Introduces computer programming and related computer science principles. Through programming, students will develop fundamental skills such as abstract reasoning and problem solving. Students will master programming techniques using the Python programming language and will develop good program design methodology resulting in correct, robust, and maintainable programs. Usually offered every semester. (Brandeis)

COSI 12b: Advanced Programming Techniques in Java (4) intro

Studies advanced programming concepts and techniques utilizing the Java programming language. The course covers software engineering concepts, object-oriented design, design patterns and professional best practices. This is a required foundation course that will prepare you for more advanced courses, new programming languages, and frameworks. Usually offered every year. (Brandeis)

COSI 121b: Structure and Interpretation of Computer Programs (4) intro

An introduction to idioms of programming methodology, and to how programming languages work. Principles of functional programming, data structures and data abstraction; state, imperative and object-oriented programming; lazy data structures; how an interpreter works; metalinguistic abstraction and programming language design; syntax analysis, lexical addressing, continuations and explicit control; continuation-passing style, metacircular and register-machine compilers. Usually offered every year. (Brandeis)

CSCI 0020: The Digital World (1) intro

Removes the mystery surrounding computers and the ever-growing digital world. Introduces a range of topics and many aspects of multimedia, along with explanations of the underlying digital technology and its relevance to our society. Other topics include artificial intelligence, IT security, ethics and the economics of computing as well as the effects of its pervasiveness in today's world. Introductory programming and analytic skills are developed through Excel, HTML, CSS, Javascript, and Python assignments. CSCI 0020 is a good introduction to a wide range of CS topics that have broad relevance in our society. (Brown)

CSCI 0111: Computing Foundations: Data (1) intro

An introduction to computing and programming that focuses on understanding and manipulating data. Students will learn to write programs to process both tabular and structured data, to assess programs both experimentally and theoretically, to apply basic data science concepts, and to discuss big ideas around the communication, use, and social impacts of digital information. Designed for both concentrators and non-concentrators, this is the first course in either a two- or three-course introductory sequence leading into advanced CS courses. Programming assignments will be smaller scale than in CSCI 0150/0170, thus allowing students time to practice programming and discuss computational ideas in a broader context. (Brown)

CSCI 0112: Computing Foundations: Program Organization (1) intro

Explores how organization of programs, data, and algorithms affects metrics such as time performance, space usage, social impacts, and data privacy. Students will learn how to choose between candidate data structures for a problem, how to write programs over several standard data structures, how to assess the quality of programs (from theoretical, practical, and social perspectives), and how to apply their skills to computational problems that could arise in a variety of fields. The course will teach object-oriented programming, in combination with basic functional and imperative programming concepts. The course is designed for both concentrators and non-concentrators. (Brown)

CSCI 0150: Introduction to Object-Oriented Programming and Computer Science (1) intro

Introduces programming in Java (a modern, widely-used programming language), interactive 2D computer graphics, and some fundamental data structures and algorithms. Students learn by programming a sequence of interactive graphics programs which gradually increase in complexity, including Doodle Jump, Tetris (http://bastilleweb.techhouse.org/), and a significant final project. Lectures are supplemented by skits performed by the UTAs (Undergraduate Teaching Assistants) to teach course concepts and for a bit of added entertainment! This course is intended for both potential concentrators and those who may take only a single course. There are NO prerequisites, and no prior knowledge of programming is required, though students who do have prior programming experience are also encouraged to take the course! (Brown)

CSCI 0170: CS: An Integrated Introduction (1) intro

CSCI 0170/0180 is an introductory sequence that helps students begin to develop the skills, knowledge, and confidence to solve computational problems elegantly, correctly, efficiently, and with ease. The sequence is unique in teaching both the functional and imperative programming paradigms---the first through the languages Scheme and ML in CSCI 0170; the second through Java in CSCI 0180. The sequence requires no previous programming experience. Indeed, few high school students are exposed to functional programming; hence even students with previous programming experience often find this sequence an invaluable part of their education. (Brown)

CSCI 0190: Accelerated Introduction to Computer Science (1) intro

A one-semester introduction to CS covering programming integrated with core data structures, algorithms, and analysis techniques, similar to the two-course introductory sequences (CSCI 0150-0200 and CSCI 0170-0200). (Brown)

CSCI 0200: Program Design with Data Structures and Algorithms (1) intro

Students extend their program-design skills while learning multiple data structures, common graph algorithms, different forms of societal impacts from programs, how to analyze programs for performance, and how to work effectively with multiple styles of programming languages. Examples and course projects draw from several areas of computer science to help students identify their broader interests within the field. There will be a required weekly lab session involving hands-on work with course material. (Brown)

CSCI 0220: Introduction to Discrete Structures and Probability (1) intro

The objective of the course is to place on solid foundations the most common structures of Computer Science, to illustrate proof techniques, to provide the background for an introductory course in computational theory and to introduce basic concepts of probability theory. It introduces Boolean algebras, logic, set theory, elements of algebraic structures, graph theory, combinatorics and probability. (Brown)

CS 1: Introduction to Computer Programming (9) intro

A course on computer programming emphasizing the program design process and pragmatic programming skills. It will use the Python programming language and will not assume previous programming experience. Material covered will include data types, variables, assignment, control structures, functions, scoping, compound data, string processing, modules, basic input/output (terminal and file), as well as more advanced topics such as recursion, exception handling and object-oriented programming. Program development and maintenance skills including debugging, testing, and documentation will also be taught. Assignments will include problems drawn from fields such as graphics, numerics, networking, and games. At the end of the course, students will be ready to learn other programming languages in courses such as CS 11, and will also be ready to take more in-depth courses such as CS 2 and CS 4. (Caltech)

CS 1 x: Intermediate Computer Programming (6) intro

An intermediate course on computer programming emphasizing the program design process and pragmatic programming skills. It will use the Java programming language and will assume previous programming experience such as an AP CS A course. Material will focus on more advanced topics such as recursion, exception handling and object-oriented programming. Program development and maintenance skills including debugging, testing, and documentation will also be taught. Assignments will include problems drawn from fields such as graphics, numerics, networking, and games. At the end of the course, students will be ready to learn other programming languages in courses such as CS 11, and will also be ready to take more in-depth courses such as CS 2 and CS 4. (Caltech)

CS 2: Introduction to Programming Methods (9) intro

CS 2 is a demanding course in programming languages and computer science. Topics covered include data structures, including lists, trees, and graphs; implementation and performance analysis of fundamental algorithms; algorithm design principles, in particular recursion and dynamic programming; Heavy emphasis is placed on the use of compiled languages and development tools, including source control and debugging. The course includes weekly laboratory exercises and projects covering the lecture material and program design. The course is intended to establish a foundation for further work in many topics in the computer science option. (Caltech)

CS 4: Fundamentals of Computer Programming (9) intro

This course gives students the conceptual background necessary to construct and analyze programs, which includes specifying computations, understanding evaluation models, and using major programming language constructs (functions and procedures, conditionals, recursion and looping, scoping and environments, compound data, side effects, higher-order functions and functional programming, and object-oriented programming). It emphasizes key issues that arise in programming and in computation in general, including time and space complexity, choice of data representation, and abstraction management. This course is intended for students with some programming background who want a deeper understanding of the conceptual issues involved in computer programming. (Caltech)

CS 111: Introduction to Computer Science (6) intro

This course will introduce you to computer programming and the design of algorithms. By writing programs to solve problems in areas such as image processing, text processing, and simple games, you will learn about recursive and iterative algorithms, complexity analysis, graphics, data representation, software engineering, and object-oriented design. No previous programming experience is necessary. Students who have received credit for Computer Science 201 or above are not eligible to enroll in Computer Science 111. (Carleton)

CS 200: Data Structures with Problem Solving (6) intro

Think back to your favorite assignment from Introduction to Computer Science. Did you ever get the feeling that “there has to be a better/smarter way to do this problem”? The Data Structures course is all about how to store information intelligently and access it efficiently. How can Google take your query, compare it to billions of web pages, and return the answer in less than one second? How can one store information so as to balance the competing needs for fast data retrieval and fast data modification? To help us answer questions like these, we will analyze and implement stacks, queues, trees, linked lists, graphs, and hash tables. This version of Data Structures includes extra class time to support students’ problem solving by meeting five days per week, and is encouraged for students who may have struggled in CS111 or otherwise believe they would benefit from extra support. This course fulfills all requirements of CS 201, and students should take only one of CS 200 or CS 201. (Carleton)

CS 201: Data Structures (6) intro

Think back to your favorite assignment from Introduction to Computer Science. Did you ever get the feeling that “there has to be a better/smarter way to do this problem”? The Data Structures course is all about how to store information intelligently and access it efficiently. How can Google take your query, compare it to billions of web pages, and return the answer in less than one second? How can one store information so as to balance the competing needs for fast data retrieval and fast data modification? To help us answer questions like these, we will analyze and implement stacks, queues, trees, linked lists, graphs, and hash tables. Students who have received credit for a course for which Computer Science 201 is a prerequisite are not eligible to enroll in Computer Science 201. (Carleton)

15-112: Fundamentals of Programming and Computer Science (12) intro

A technical introduction to the fundamentals of programming with an emphasis on producing clear, robust, and reasonably efficient code using top-down design, informal analysis, and effective testing and debugging. Starting from first principles, we will cover a large subset of the Python programming language, including its standard libraries and programming paradigms. We will also target numerous deployment scenarios, including standalone programs, shell scripts, and web-based applications. This course assumes no prior programming experience. Even so, it is a fast-paced and rigorous preparation for 15-122. Students seeking a more gentle introduction to computer science should consider first taking 15-110. NOTE: students must achieve a C or better in order to use this course to satisfy the pre-requisite for any subsequent Computer Science course. (CMU)

15-121: Introduction to Data Structures (10) intro

A continuation of the process of program design and analysis for students with some prior programming experience (functions, loops, and arrays, not necessarily in Java). The course reinforces object-oriented programming techniques in Java and covers data aggregates, data structures (e.g., linked lists, stacks, queues, trees, and graphs), and an introduction to the analysis of algorithms that operate on those data structures. (CMU)

15-122: Principles of Imperative Computation (12) intro

For students with a basic understanding of programming (variables, expressions, loops, arrays, functions). Teaches imperative programming and methods for ensuring the correctness of programs. Students will learn the process and concepts needed to go from high-level descriptions of algorithms to correct imperative implementations, with specific application to basic data structures and algorithms. Much of the course will be conducted in a subset of C amenable to verification, with a transition to full C near the end. This course prepares students for 15-213 and 15-210. NOTE: students must achieve a C or better in order to use this course to satisfy the pre-requisite for any subsequent Computer Science course. (CMU)

15-150: Principles of Functional Programming (12) intro

An introduction to programming based on a 'functional' model of computation. The functional model is a natural generalization of algebra in which programs are formulas that describe the output of a computation in terms of its inputs and #8212;-that is, as a function. But instead of being confined to real- or complex-valued functions, the functional model extends the algebraic view to a very rich class of data types, including not only aggregates built up from other types, but also functions themselves as values. This course is an introduction to programming that is focused on the central concepts of function and type. One major theme is the interplay between inductive types, which are built up incrementally; recursive functions, which compute over inductive types by decomposition; and proof by structural induction, which is used to prove the correctness and time complexity of a recursive function. Another major theme is the role of types in structuring large programs into separate modules, and the integration of imperative programming through the introduction of data types whose values may be altered during computation. NOTE: students must achieve a C or better in order to use this course to satisfy the pre-requisite for any subsequent Computer Science course. (CMU)

15-210: Parallel and Sequential Data Structures and Algorithms (12) intro

Teaches students about how to design, analyze, and program algorithms and data structures. The course emphasizes parallel algorithms and analysis, and how sequential algorithms can be considered a special case. The course goes into more theoretical content on algorithm analysis than 15-122 and 15-150 while still including a significant programming component and covering a variety of practical applications such as problems in data analysis, graphics, text processing, and the computational sciences. NOTE: students must achieve a C or better in order to use this course to satisfy the pre-requisite for any subsequent Computer Science course. Register for Lecture 1. All students will be waitlisted for Lecture 2 until Lecture 1 is full. (CMU)

15-213: Introduction to Computer Systems (12) intro

This course provides a programmer's view of how computer systems execute programs, store information, and communicate. It enables students to become more effective programmers, especially in dealing with issues of performance, portability and robustness. It also serves as a foundation for courses on compilers, networks, operating systems, and computer architecture, where a deeper understanding of systems-level issues is required. Topics covered include: machine-level code and its generation by optimizing compilers, performance evaluation and optimization, computer arithmetic, memory organization and management, networking technology and protocols, and supporting concurrent computation. NOTE FOR GRADUATE STUDENTS: This course is not open to graduate students beginning Spring 2015. Graduate students must register for 15-513 instead. (CMU)

17-214: Principles of Software Construction: Objects, Design, and Concurrency (12) intro

Software engineers today are less likely to design data structures and algorithms from scratch and more likely to build systems from library and framework components. In this course, students engage with concepts related to the construction of software systems at scale, building on their understanding of the basic building blocks of data structures, algorithms, and program and computer structures. The course covers technical topics in four areas: (1) concepts of design for complex systems, (2) object-oriented programming, (3) static and dynamic analysis for programs, and (4) concurrency. At the conclusion of this course, students will have substantial experience building medium-sized software systems in Java or JavaScript. (CMU)

CSDS 101: The Digital Revolution: Computer and Data Science For All (4) intro

For students who want to explore the history, the current state, and future challenges of computer and data sciences. Topics include how computers work, computational thinking, how software development differs from traditional manufacturing, the Internet and World Wide Web, social networks, data collection, search engines and data mining, machine learning, trends in computer crime, security, and privacy, how technology is changing our laws and culture. The class includes a lab component where students will be introduced to the Python programming language and other technologies and applications in order to further explore these topics. (Case)

CSDS 132: Programming in Java (3) intro

An in-depth survey of modern programming language features, computer programming and algorithmic problem solving with an emphasis on the Java language. Computers and code compilation; conditional statements, subprograms, loops, methods; object-oriented design, inheritance and polymorphism, abstract classes and interfaces; types, type systems, generic types, abstract data types, strings, arrays, linked lists; software development, modular code design, unit testing; strings, text and file I/O; GUI components, GUI event handling; threads; comparison of Java to C, C++, and C#. Offered as CSDS 132 and ECSE 132. (Case)

CSDS 133: Introduction to Data Science and Engineering for Majors (3) intro

This course is an introduction to data science and analytics. In the first half of the course, students will develop a basic understanding of how to manipulate, analyze and visualize large data in a distributed computing environment, with an appreciation of open source development, security and privacy issues. Case studies and team project assignments in the second half of the course will be used to implement the ideas. Topics covered will include: Overview of large scale parallel and distributed (cloud) computing; file systems and file i/o; open source coding and distributed versioning, data query and retrieval; basic data analysis; visualization; data security, privacy and provenance. (Case)

CSDS 233: Introduction to Data Structures (4) intro

Different representations of data: lists, stacks and queues, trees, graphs, and files. Manipulation of data: searching and sorting, hashing, recursion and higher order functions. Abstract data types, templating, and the separation of interface and implementation. Introduction to asymptotic analysis. The Java language is used to illustrate the concepts and as an implementation vehicle throughout the course. Offered as CSDS 233 and ECSE 233. (Case)

CSDS 234: Structured and Unstructured Data (3) intro

This course is an introduction to types of data and their representation, storage, processing and analysis. The course has three parts. In the first part of the course, students will develop a basic understanding and the ability to represent, store, process and analyze structured data. Structured data include catalogs, records, tables, logs, etc., with a fixed dimension and well-defined meaning for each data point. Suitable representation and storage mechanisms include lists and arrays. Relevant techniques include keys, hashes, stacks, queues and trees. In the second part of the course, students will develop a basic understanding and the ability to represent, store, process and analyze semi-structured data. Semi-structured data include texts, web pages and networks, without a dimension and structure, but with well-defined meaning for each data point. Suitable representation and storage mechanisms include trees, graphs and RDF triples. Relevant techniques include XML, YAML, JSON, parsing, annotation, language processing. In the third part of the course, students will develop a basic understanding and the ability to represent, store, process and analyze unstructured data. Unstructured data include images, video, and time series data, without neither a fixed dimension and structure, nor well-defined meaning for individual data points. Suitable representation and storage mechanisms include large matrices, EDF, DICOM. Relevant techniques include feature extraction, segmentation, clustering, rendering, indexing, and visualization. (Case)

CSDS 236: Introduction to C/C++ Programming (1) intro

This course provides an introduction to C and C++ programming languages. Prior knowledge of these languages is not expected. However, students are expected to know at least one programming language prior to the class. The lectures will cover low-level programming techniques and object-oriented class design. Students will learn specific topics in C/C++ including required background knowledge, pointers & references, memory management, inheritance, polymorphism, templates, exceptions, use of debugging and compiler tools, and others as time permits. (Case)

CSDS 245: Functional Programming in Java (1) intro

An introduction to functional programming elements and attendant constructs in the Java programming language. Generics, enumerated types, records, and access to class members. Advanced control flow. The Java Collection Framework. Functional interfaces: lambdas, comparators, and standard functional interfaces. Optionals. Stream, collectors, and map-reduce. (Case)

CP110: Explorations in Computer Science (1) intro

No offerings are currently scheduled. (Colorado)

CP115: Computational Thinking (1) intro

Introduction to the encoding of information as data and the automation of quantitative reasoning with computer programs. This course covers the basics of the Python programming language with examples drawn from many fields (e.g. chemistry, biology, linguistics, art, music). This is the first course for those interested in computer science. (Colorado)

CP116: Applied Python (1) intro

In-depth exploration of the Python programming language and its applications, with emphasis on object-oriented Python, data visualization, and data analysis. A brief review of Python will be provided for students entering with prior programming experience that does not include Python. (Colorado)

CP122: Computer Science I (1) intro

Introduction to algorithms and data structures, and the design of computer programs using the programming language Java. This course requires some experience in programming. (Colorado)

CP222: Computer Science II (1) intro

Study of the design and implementation of computer programs in Java at the intermediate level with a focus on object-oriented programming. Foundational concepts that lead towards formal discussion of software design (e.g. design patterns), analysis of algorithms (e.g. asymptotic complexity), and computer architecture (e.g. stack/heap memory) are introduced in this course. Students will use data structures and other tools to build robust, efficient, extensible programs that utilize Graphical User Interfaces (GUIs). The concepts behind multi-threaded programming are also introduced. Students will also deepen their understanding of how computers manipulate memory and execute programs. (Colorado)

COMS W1002: Computing in Context (4) intro

Introduction to elementary computing concepts and Python programming with domain-specific applications. Shared CS concepts and Python programming lectures with track-specific sections. Track themes will vary but may include computing for the social sciences, computing for economics and finance, digital humanities, and more. Intended for nonmajors. Students may only receive credit for one of ENGI E1006 or COMS W1002 (Columbia)

COMS W1004: Introduction to Computer Science and Programming in Java (3) intro

A general introduction to computer science for science and engineering students interested in majoring in computer science or engineering. Covers fundamental concepts of computer science, algorithmic problem-solving capabilities, and introductory Java programming skills. Assumes no prior programming background. Columbia University students may receive credit for only one of the following two courses: 1004 or 1005. (Columbia)

COMS W1005: Introduction to Computer Science and Programming in MATLAB (3) intro

A general introduction to computer science concepts, algorithmic problem-solving capabilities, and programming skills in MATLAB. Assumes no prior programming background. Columbia University students may receive credit for only one of the following two courses: W1004 or W1005. (Columbia)

COMS W1011: Intermed Computer Programming (3) intro

(Columbia)

COMS W1012: Computing in Context Rec (0) intro

(Columbia)

COMS W1103: Honors Intro Computer Science (3) intro

(Columbia)

COMS W3011: Intermed Computer Programming (3) intro

(Columbia)

COMS W3132: Intermediate Computing in Python (4) intro

Essential data structures and algorithms in Python with practical software development skills, applications in a variety of areas including biology, natural language processing, data science and others (Columbia)

COMS W3134: Data Structures in Java (3) intro

Data types and structures: arrays, stacks, singly and doubly linked lists, queues, trees, sets, and graphs. Programming techniques for processing such structures: sorting and searching, hashing, garbage collection. Storage management. Rudiments of the analysis of algorithms. Taught in Java. (Columbia)

COMS W3136: Essential Data Structures (4) intro

A second programming course intended for nonmajors with at least one semester of introductory programming experience. Basic elements of programming in C and C , arraybased data structures, heaps, linked lists, C programming in UNIX environment, object-oriented programming in C , trees, graphs, generic programming, hash tables. (Columbia)

COMS W3137: Honors Data Structures & Algorithms (4) intro

An honors introduction to data types and structures: arrays, stacks, singly and doubly linked lists, queues, trees, sets, and graphs. Programming techniques for processing such structures: sorting and searching, hashing, garbage collection. Storage management. Design and analysis of algorithms. Taught in Java. Note: Due to significant overlap, students may receive credit for only one of the following three courses: COMS W3134, W3136, or W3137 (Columbia)

CS 1109: Fundamental Programming Concepts (2) intro

Designed for students who intend to take CS 1110 or CS 1112 and wish to get a head start, CS 1109 focuses on basic programming concepts and problem analysis and decomposition. The programming concepts to be studied include control flow, function, and list. An appropriate high-level programming language is used. (Cornell)

CS 1110: Introduction to Computing: A Design and Development Perspective (4) intro

Programming and problem solving using Python. Emphasizes principles of software development, style, and testing. Topics include procedures and functions, iteration, recursion, arrays and vectors, strings, an operational model of procedure and function calls, algorithms, exceptions, object-oriented programming. (Cornell)

CS 1112: Introduction to Computing: An Engineering and Science Perspective (4) intro

Programming and problem solving using Python. Emphasizes the systematic development of algorithms and programs. Topics include iteration, functions, arrays, strings, recursion, object-oriented programming, algorithms, and data handling and visualization. (Cornell)

CS 1132: Short Course in MATLAB (1.5) intro

Introduction to the MATLAB programming language. Covers the basic programming constructs of MATLAB, including assignment, conditionals, iteration, functions, arrays, vectorized computation, and scientific graphics. Designed for students who need MATLAB for research or other courses. Does not assume any previous programming experience. (Cornell)

CS 1133: Short Course in Python (1.5) intro

Introduction to the Python programming language. Covers the basic programming constructs of Python, including assignment, conditionals, iteration, functions, object-oriented design, arrays, and vectorized computation. Designed for students who need Python for research or other courses. Does not assume any previous programming experience. (Cornell)

CS 2024: C++ Programming (2) intro

Fall. 2 credits. S/U grades only. R. DiNapoli. An intermediate introduction to the C++ programming language and the C/C++ standard libraries. Topics include basic statements, declarations, and types; stream I/O; user-defined classes and types; derived classes, inheritance, and object-oriented programming; exceptions and templates. Recommended for students who plan to take advanced courses in computer science that require familiarity with C++ or C. (Cornell)

CS 2110: Object-Oriented Programming and Data Structures (4) intro

Fall, Spring, Summer. 4 credits. Student option grading. C. Muhlberger, A. Myers. Intermediate programming in a high-level language and introduction to computer science. Topics include object-oriented programming (classes, objects, subclasses, types), graphical user interfaces, algorithm analysis (asymptotic complexity, big “O” notation), recursion, testing, program correctness (loop invariants), searching/sorting, data structures (lists, trees, stacks, queues, heaps, search trees, hash tables, graphs), graph algorithms. Java is the principal programming language. (Cornell)

CS 2112: Object-Oriented Design and Data Structures - Honors (4) intro

Fall. Not offered: 2023-2024. Next offered: 2024-2025. 4 credits. Student option grading (no audit). N Foster. Intermediate software design and introduction to key computer science ideas. Topics are similar to those in CS 2110 but are covered in greater depth, with more challenging assignments. Topics include object-oriented programming, program structure and organization, program reasoning using specifications and invariants, recursion, design patterns, concurrent programming, graphical user interfaces, data structures as in CS 2110, sorting and graph algorithms, asymptotic complexity, and simple algorithm analysis. Java is the principal programming language. (Cornell)

CS 3110: Data Structures and Functional Programming (4) intro

Advanced programming course that emphasizes functional programming techniques and data structures. (Cornell)

COSC 1: Introduction to Programming and Computation (1) intro

This course introduces computational concepts fundamental to computer science and useful for various fields. Students will write interactive programs to analyze data, process text, draw graphics, manipulate images, and simulate physical systems. Emphasis on problem decomposition, program efficiency, and good programming style. (Dartmouth)

COSC 10: Problem Solving via Object-Oriented Programming (1) intro

This course examines concepts and skills in solving computational problems. Topics include abstraction, modularity, data structures, and algorithms. Laboratory assignments use object-oriented programming techniques. (Dartmouth)

CPS 111: Computer Science I (1) intro

Introduces basic concepts in computer science and computational problem solving through the design of algorithms and computational processes, modularization, and abstraction. Also introduces the processes of programming and software development as a means to put solutions into practice. Has a required lab, but does not satisfy the 'Natural Science with Laboratory' requirement. (F&M)

CPS 112: Computer Science II (1) intro

A second course in computer science and computational thinking, focusing on data structures and advanced programming. Topics include implementation and applications of data structures such as stacks, queues, linked lists, trees and graphs. Also introduces performance analysis of algorithms. Has a required lab, but does not satisfy the 'Natural Science with Laboratory' requirement. (F&M)

CS 1301: Introduction to Computing (3) intro

Introduction to computing principles and programming practices with an emphasis on the design, construction and implementation of problem solutions use of software tools. (Georgia Tech)

CS 1315: Introduction to Media Computation (3) intro

Introduction to computation (algorithmic thinking, data structures, data transformation and processing, and programming) in a media and communication context. Credit not awarded for both CS 4452 and CS 1315. (Georgia Tech)

CS 1331: Introduction to Object Oriented Programming (3) intro

Introduction to techniques and methods of object-oriented programming such an encapsulation, inheritance, and polymorphism. Emphasis on software development and individual programming skills. (Georgia Tech)

CS 1332: Data Structures and Algorithms for Applications (3) intro

Computer data structures and algorithms in the context of object-oriented programming. Focus on software development towards applications. (Georgia Tech)

CS 2340: Objects and Design (3) intro

Object-oriented programming methods for dealing with large programs. Focus on quality processes, effective debugging techniques, and testing to assure a quality product. (Georgia Tech)

COMPSCI 1: Great Ideas in Computer Science (4) intro

An introduction to the most important discoveries and intellectual paradigms in computer science, designed for students with little or no previous background. Explores problem-solving and data analysis using Python, a programming language with a simple syntax and a powerful set of libraries. This course covers basic data types and collections (lists, dictionaries, tuples, and sets), control flow, recursion, supervised machine learning via regression, visualization, information hiding and encapsulation using classes and objects, and introduces the analysis of program performance. Presents an integrated view of computer systems, from switching circuits up through compilers, and examines theoretical and practical limitations related to unsolvable and intractable computational problems. Other topics include the social and ethical dilemmas presented by such issues as software unreliability, algorithmic bias, and invasions of privacy. (Harvard)

COMPSCI 32: Computational Thinking and Problem Solving (4) intro

An introduction to computational thinking, useful concepts in the field of computer science, and the art of computer programming using Python. Significant emphasis is placed on class meetings and learning to use computers to solve complex, real-world problems. Concepts and techniques are introduced as they are needed to help solve the problems confronting us. Students will learn how to go from an ambiguous problem description to a running solution and will leave the class knowing how to instruct computers to do what they want them to do. Prior experience in computer science or computer programming is not necessary. (Harvard)

COMPSCI 50: Introduction to Computer Science (4) intro

This is COMPSCI 50, Harvard University's introduction to the intellectual enterprises of computer science and the art of programming, for concentrators and non-concentrators alike, with or without prior programming experience. (More than half of COMPSCI 50 students have never taken CS before!) This course teaches you how to solve problems, both with and without code, with an emphasis on correctness, design, and style. Topics include computational thinking, abstraction, algorithms, data structures, and computer science more generally. Problem sets inspired by the arts, humanities, social sciences, and sciences. More than teach you how to program in one language, this course teaches you how to program fundamentally and how to teach yourself new languages ultimately. The course starts with a traditional but omnipresent language called C that underlies today's newer languages, via which you'll learn not only about functions, variables, conditionals, loops, and more, but also about how computers themselves work underneath the hood, memory and all. The course then transitions to Python, a higher-level language that you'll understand all the more because of C. Toward term's end, the course introduces SQL, via which you can store data in databases, along with HTML, CSS, and JavaScript, via which you can create web and mobile apps alike. Course culminates in a final project. See https://cs50.harvard.edu/college for advice, FAQs, syllabus, and what's new. Email the course's heads at heads@cs50.harvard.edu with questions. (Harvard)

COMPSCI 51: Abstraction and Design in Computation (4) intro

Fundamental concepts in the design of computer programs, emphasizing the crucial role of abstraction. The goal of the course is to give students insight into the difference between programming and programming well. To emphasize the differing approaches to expressing programming solutions, you will learn to program in a variety of paradigms -- including functional, imperative, and object-oriented. Important ideas from software engineering and models of computation will inform these different views of programming. (Harvard)

6.100A: Introduction to Computer Science Programming in Python (6) intro

Introduction to computer science and programming for students with little or no programming experience. Students develop skills to program and use computational techniques to solve problems. Topics include the notion of computation, Python, simple algorithms and data structures, testing and debugging, and algorithmic complexity. (MIT)

6.100B: Introduction to Computational Thinking and Data Science (6) intro

Provides an introduction to using computation to understand real-world phenomena. Topics include plotting, stochastic programs, probability and statistics, random walks, Monte Carlo simulations, modeling data, optimization problems, and clustering. (MIT)

6.100L: Introduction to Computer Science and Programming (9) intro

Introduction to computer science and programming for students with no programming experience. Presents content taught in 6.100A over an entire semester. Students develop skills to program and use computational techniques to solve problems. Topics include the notion of computation, Python, simple algorithms and data structures, testing and debugging, and algorithmic complexity. (MIT)

6.1010: Fundamentals of Programming (8) intro

Introduces fundamental concepts of programming. Designed to develop skills in applying basic methods from programming languages to abstract problems. Topics include programming and Python basics, computational concepts, software engineering, algorithmic techniques, data types, and recursion. (MIT)

CS 1100: Computer Science and Its Applications (4) intro

Introduces students to the field of computer science and the patterns of thinking that enable them to become intelligent users of software tools in a problem-solving setting. Examines several important software applications so that students may develop the skills necessary to use computers effectively in their own disciplines. (Northeastern)

CS 1101: Lab for CS 1100 (1) intro

Accompanies CS 1100. Involves experiments and problem solving across multiple disciplines using computer science techniques and tools. (Northeastern)

DS 2000: Programming with Data (2) intro

Introduces programming for data and information science through case studies in business, sports, education, social science, economics, and the natural world. Presents key concepts in programming, data structures, and data analysis through Python and Excel. (Northeastern)

DS 2001: Data Science Programming Practicum (2) intro

Applies data science principles in interdisciplinary contexts, with each section focusing on applications to a different discipline. Involves new experiments and readings in multiple disciplines (both computer science and the discipline focus of the particular section). Requires multiple projects combining interdisciplinary subjects. (Northeastern)

CS 2500: Fundamentals of Computer Science 1 (4) intro

Introduces the fundamental ideas of computing and the principles of programming. Discusses a systematic approach to word problems, including analytic reading, synthesis, goal setting, planning, plan execution, and testing. Presents several models of computing, starting from nothing more than expression evaluation in the spirit of high school algebra. No prior programming experience is assumed; therefore, suitable for freshman students, majors and nonmajors alike who wish to explore the intellectual ideas in the discipline. (Northeastern)

DS 2500: Intermediate Programming with Data (4) intro

Offers intermediate to advanced Python programming for data science. Covers object-oriented design patterns using Python, including encapsulation, composition, and inheritance. Advanced programming skills cover software architecture, recursion, profiling, unit testing and debugging, lineage and data provenance, using advanced integrated development environments, and software control systems. (Northeastern)

CS 2501: Lab for CS 2500 (1) intro

Accompanies CS 2500. Covers topics from the course through various experiments. (Northeastern)

DS 2501: Lab for DS 2500 (1) intro

Practices the programming techniques discussed in DS 2500 through hands-on experimentation. (Northeastern)

CS 2510: Fundamentals of Computer Science 2 (4) intro

Continues CS 2500. Examines object-oriented programming and associated algorithms using more complex data structures as the focus. Discusses nested structures and nonlinear structures including hash tables, trees, and graphs. Emphasizes abstraction, encapsulation, inheritance, polymorphism, recursion, and object-oriented design patterns. Applies these ideas to sample applications that illustrate the breadth of computer science. (Northeastern)

CS 2511: Lab for CS 2510 (1) intro

Accompanies CS 2510. Covers topics from the course through various experiments. (Northeastern)

CS 3500: Object-Oriented Design (4) intro

Presents a comparative approach to object-oriented programming and design. Discusses the concepts of object, class, meta-class, message, method, inheritance, and genericity. Reviews forms of polymorphism in object-oriented languages. Contrasts the use of inheritance and composition as dual techniques for software reuse: forwarding vs. delegation and subclassing vs. subtyping. Fosters a deeper understanding of the principles of object-oriented programming and design including software components, object-oriented design patterns, and the use of graphical design notations such as UML (unified modeling language). Basic concepts in object-oriented design are illustrated with case studies in application frameworks and by writing programs in one or more object-oriented languages. (Northeastern)

CS 3501: Lab for CS 3500 (1) intro

Accompanies CS 3500. Covers topics from the course and provides students with additional opportunities to engage with course material. (Northeastern)

COMP_SCI 110-0: Introduction to Computer Programming (1) intro

Introduction to programming practice using a modern programming language. Analysis and formulation of problems for computer solution. Systematic design, construction, and testing of programs. Substantial programming assignments. Not to be taken for credit with or after COMP_SCI 111-0. (Northwestern)

COMP_SCI 111-0: Fundamentals of Computer Programming (1) intro

Fundamental concepts of computer programming with heavy emphasis on design of recursive algorithms and test-driven development. Functional, imperative, and object-oriented programming paradigms. Procedural abstraction, data abstraction, and modularity. Required for the computer science degree. (Northwestern)

COMP_SCI 150-0: Fundamentals of Computer Programming 1.5 (1) intro

An introduction to Object-oriented programming: focus on Python but including a brief introduction to a statically typed language (e.g. C++). Students will use some approaches from Artificial Intelligence and Machine Learning to complete programming assignments. Required for the computer science degree. (Northwestern)

COMP_SCI 211-0: Fundamentals of Computer Programming II (1) intro

CS 211 teaches foundational software design skills at a small-to-medium scale. We aim to provide a bridge from the student-oriented How to Design Programs languages to real, industry-standard languages and tools. Topics include expressions, statements, types, functions, branches and iteration, user-defined types, data hiding, basic UNIX shell usage, and testing. (Northwestern)

CSCI 051A: Introduction to Computer Science Exploring Topics in Artificial Intelligence (1) intro

An introduction to computer science exploring topics in artificial intelligence (AI). The course will cover core programming concepts including iteration and recursion, basic data structures, and object-oriented programming using Python motivated by AI applications such as problem solving via search, game playing and basic machine learning. Students must take a lab associated with this section only. No previous programming experience required or expected. (Pomona)

CSCI 051P: Introduction to Computer Science in Python with Laboratory (1) intro

Introduction to the field of computer science using the Python programming language. Topics include iteration and recursion, basic data structures, sorting and searching, elementary analysis of algorithms, and an introduction to object-oriented programming. Special emphasis on working with and making sense of data in order to connect course material with applications in other disciplines. Students must take a lab associated with this section only. No previous programming experience required or expected. (Pomona)

CSCI 054: Discrete Math and Functional Programming (1) intro

A combined course on functional programming and formal proof. Students write programs over a variety of data structures, proving their programs correct with respect to precise logical specifications. Programming topics (and proof topics) range over: recursion (induction); combinatorics; algebraic data types, from lists to trees to abstract syntax trees (structural induction); parsers and interpreters (soundness properties); regular expressions (set theory and language theory). Prerequisites: any CSCI 051x course or Computer Science AP Exam-A with a score of 5. (Pomona)

CSCI 062: Data Structures and Advanced Programming (1) intro

Key topics include abstract data types (including stacks, queues, trees, priority queues and dynamic dictionaries), analysis of algorithms (including worst-case, average-case and amortized analysis) and program verification. Extensive practice in Java. Serves the same role as HM 70 as a prerequisite for upper-division computer science courses at any of The Claremont Colleges. (Pomona)

COS 126: Computer Science: An Interdisciplinary Approach (1) intro

An introduction to computer science in the context of scientific, engineering, and commercial applications. The course will teach basic principles and practical issues, and will prepare students to use computers effectively for applications in computer science, physics, biology, chemistry, engineering, and other disciplines. Topics include: hardware and software systems; programming in Java; algorithms and data structures; fundamental principles of computation; and scientific computing, including simulation, optimization, and data analysis. No prior programming experience required. Video lectures, one class, two preceptorials. A. Kaplan, K. Wayne (Princeton)

COS 217: Introduction to Programming Systems (1) intro

An introduction to computer organization and system software. The former includes topics such as processor and memory organization, input/output devices, and interrupt structures. The latter includes assemblers, loaders, libraries, and compilers. Programming assignments are implemented in assembly language and C using the UNIX operating system. Three lectures. (Princeton)

COS 333: Advanced Programming Techniques (1) intro

The practice of programming. Emphasis is on the development of real programs, writing code but also assessing tradeoffs, choosing among design alternatives, debugging and testing, and improving performance. Issues include compatibility, robustness, and reliability, while meeting specifications. Students will have the opportunity to develop skills in these areas by working on their own code and in group projects. Two 90-minute lectures. (Princeton)

CS 17600: Data Engineering In Python (3) intro

The course introduces students to programming fundamentals in Python, including loops, functions and different data types, and provides an introduction to data engineering including working with common data formats and learning the basics of data wrangling. Students will format, extract, clean, filter, transform, search, combine, summarize, aggregate, and visualize a diverse range of data sets. Python libraries including Matplotlib and Pandas are used. (Purdue)

CS 17700: Programming With Multimedia Objects (4) intro

Introduction to computers and programming: number representations, primitive data types and operations, basic control structures, programming applets and applications using graphical user interfaces, programming for detecting events and performing actions, processing multimedia objects such as images and sounds. Throughout the course, examples are drawn from a variety of fields in the natural sciences. (Purdue)

CS 18000: Problem Solving And Object-Oriented Programming (4) intro

Problem solving and algorithms, implementation of algorithms in a high level programming language, conditionals, the iterative approach and debugging, collections of data, searching and sorting, solving problems by decomposition, the object-oriented approach, subclasses of existing classes, handling exceptions that occur when the program is running, graphical user interfaces (GUIs), data stored in files, abstract data types, a glimpse at topics from other CS courses. (Purdue)

CS 18200: Foundations Of Computer Science (3) intro

Logic and proofs; sets, functions, relations, sequences and summations; number representations; counting; fundamentals of the analysis of algorithms; graphs and trees; proof techniques; recursion; Boolean logic; finite state machines; pushdown automata; computability and undecidability. (Purdue)

CS 24000: Programming In C (3) intro

The UNIX environment, C development cycle, data representation, operators, program structure, recursion, macros, C preprocessor, pointers and addresses, dynamic memory allocation, structures, unions, typedef, bit-fields, pointer/structure applications, UNIX file abstraction, file access, low-level I/O, concurrency. (Purdue)

CS 25000: Computer Architecture (4) intro

Digital logic: transistors, gates, and combinatorial circuits; clocks; registers and register banks; arithmetic-logic units; data representation: big-endian and little-endian integers; ones and twos complement arithmetic; signed and unsigned values; Von-Neumann architecture and bottleneck; instruction sets; RISC and CISC designs; instruction pipelines and stalls; rearranging code; memory and address spaces; physical and virtual memory; interleaving; page tables; memory caches; bus architecture; polling and interrupts; DMA; device programming; assembly language; optimizations; parallelism; data pipelining. (Purdue)

CS 25100: Data Structures And Algorithms (3) intro

Running time analysis of algorithms and their implementations, one-dimensional data structures, trees, heaps, additional sorting algorithms, binary search trees, hash tables, graphs, directed graphs, weighted graph algorithms, additional topics. (Purdue)

CS 38001: C++ Programming (1) intro

This course builds on the CS 24000 (Programming In C) course to teach C++ extensions. This 5-week one-credit course teaches C++ programming and helps students improve their understanding of object-oriented programming. It also teaches how to use an Integrated Development Environment (IDE) when programming in C++. (Purdue)

CS 38002: Advanced Java Programming (1) intro

This course builds on the Java course CS 18000 (Problem Solving And Object Oriented Programming) to teach advanced topics in Java. This 5-week one-credit course will teach advanced topics such as Network Programming in Java, JDBC, JNI, and J2EE to write web applications in Java. You will also improve your understanding of Object Oriented Programming. (Purdue)

CS 38003: Python Programming (1) intro

This course teaches the Python programming language assuming that students have already taken a course in computer programming. This 5-week one-credit course teaches the Python language, the most common modules used in Python, as well as how to write Python web applications. (Purdue)

COMP 140: Computational Thinking (4) intro

An introduction to computational problem solving designed to give an overview of computer science using real-world problems across a broad range of disciplines. Students learn how to think about these problems and how to structure effective solutions to them using computation. No programming knowledge is required or expected; students learn how to implement their solutions in Python. If you register for fully online section, you must have a webcam and you must take the exams in person. (Rice)

COMP 160: Introduction to Game Programming in Python (4) intro

This class covers the basics of Python Programming with a focus on building simple games in a web-based environment. The class includes an introduction to event-driven programming and trains the students in the specifics of a Python GUI system designed to support creating to support creating applications that run in a web browser. This course is limited to first-year students only. Continuing Students may register with an approved Special Registration Form. (Rice)

COMP 180: Principles of Computing (4) intro

This class is designed for non-majors interested in a broader understanding of Computer Science and focuses on intermediate-level programming in Python as well as the basics of discrete math. The class concludes with an introduction to the process of Algorithmic Thinking. Note that COMP 180 cannot be substituted for COMP 182 as a pre-requisite for upper level CS classes. Instructor Permission Required. (Rice)

COMP 215: Introduction to Program Design (4) intro

This course covers the principles of programming and program design. The course is organized around a number of individual programming assignments that fit together to complete a significant, real-world application. Each assignment emphasizes one or more of the basic principles of software design, including: encapsulation, abstraction, test-driven development, and functional and object-oriented programming. The Java programming language will be used. An introduction to the basics of the Java language itself (including Java syntax and semantics) will be provided. (Rice)

CSSE 120: Introduction to Software Development (4) intro

An introduction to programming with an emphasis on problem solving. Problems may include visualizing data, interfacing with external hardware or solving problems from a variety of engineering disciplines. Programming concepts covered include data types, variables, control structures, arrays, and data I/O. Software development concepts covered include testing, debugging, incremental development, understanding requirements, and version control systems. (Rose-Hulman)

CSSE 220: Object-Oriented Software Development (4) intro

Object-oriented programming concepts, including the use of inheritance, interfaces, polymorphism, abstract data types, and encapsulation to enable software reuse and assist in software maintenance. Recursion, GUIs and event handing. Use of common object-based data structures, including stacks, queues, lists, trees, sets, maps, and hash tables. Space/time efficiency analysis. Testing. Introduction to UML. (Rose-Hulman)

CSSE 221: Fundamentals of Software Development Honors (4) intro

This course is intended for students who have sufficient programming experience to warrant placement in an accelerated course covering the topics from CSSE 120 and CSSE 220. This course will satisfy the prerequisite requirements for courses that have CSSE 220 as a prerequisite. (Rose-Hulman)

CSSE 225: Programming 3 (4) intro

Differences between Java and C++. C++ concepts of object-oriented programming (classes, objects, inheritance, polymorphism). Storage management. Multiple inheritance, operator overloading, friend-concept, exception handling, I/O. Error analysis of programs. Generic programming and introduction to C++ - standard library. This course is taught as part of the International Computer Science dual degree program at Hochschule Ulm, Germany. (Rose-Hulman)

CSSE 230: Data Structures and Algorithm Analysis (4) intro

This course reinforces and extends students’ ability to independently design, develop, and debug object-oriented software that uses correct, clear, and efficient algorithms and data structures. Students study and implement classical data structures such as list, stack, queue, tree, priority queue, hash table, graph, set, and dictionary. Formal efficiency analysis is used to evaluate the complexity of algorithms for these data structures. Students gain proficiency in writing recursive methods. Students design and implement software individually. (Rose-Hulman)

CS 41: Hap.py Code: The Python Programming Language (2) intro

This course is about the fundamentals and contemporary usage of the Python programming language. The primary focus is on developing best practices in writing Python and exploring the extensible and unique parts of the Python language. Topics include: Pythonic conventions, data structures such as list comprehensions, anonymous functions, iterables, powerful built-ins (e.g. map, filter, zip), and Python libraries. For the last few weeks, students will work with course staff to develop their own significant Python project. (Stanford)

CS 51: CS + Social Good Studio: Designing Social Impact Projects (2) intro

Get real-world experience researching and developing your own social impact project! Students work in small teams to develop high-impact projects around problem domains provided by partner organizations, under the guidance and support of design/technical coaches from industry and non-profit domain experts. Main class components are workshops, community discussions, guest speakers and mentorship. Studio provides an outlet for students to create social change through CS while engaging in the full product development cycle on real-world projects. The class culminates in a showcase where students share their project ideas and Minimum Viable Product prototypes with stakeholders and the public. Application required; please see CS 51.stanford.edu for more information. (Stanford)

CS 52: CS + Social Good Studio: Implementing Social Good Projects (2) intro

Continuation of CS 51 (CS + Social Good Studio). Teams enter the quarter having completed and tested a minimal viable product (MVP) with a well-defined target user, and a community partner. Students will learn to apply scalable technical frameworks, methods to measure social impact, tools for deployment, user acquisition techniques and growth/exit strategies. The purpose of the class is to facilitate students to build a sustainable infrastructure around their product idea. CS 52 will host mentors, guest speakers and industry experts for various workshops and coaching-sessions. The class culminates in a showcase where students share their projects with stakeholders and the public. (Stanford)

CS 100ACE: Problem-solving Lab for CS 106A (1) intro

Additional problem solving practice for the introductory CS course CS 106A. Sections are designed to allow students to acquire a deeper understanding of CS and its applications, work collaboratively, and develop a mastery of the material. Limited enrollment, permission of instructor required. Concurrent enrollment in CS 106A required. (Stanford)

CS 105: Introduction to Computers (35) intro

For non-technical majors. What computers are and how they work. Practical experience in development of websites and an introduction to programming. A survey of Internet technology and the basics of computer hardware. Students in technical fields and students looking to acquire programming skills should take 106A or 106X. Students with prior computer science experience at the level of 106 or above require consent of instructor. (Stanford)

CS 106A: Programming Methodology (35) intro

Introduction to the engineering of computer applications emphasizing modern software engineering principles: program design, decomposition, encapsulation, abstraction, and testing. Emphasis is on good programming style and the built-in facilities of respective languages. Uses the Python programming language. No prior programming experience required. (Stanford)

CS 106AX: Programming Methodologies in JavaScript and Python (Accelerated) (35) intro

Introduction to the engineering of computer applications emphasizing modern software engineering principles: object-oriented design, decomposition, encapsulation, abstraction, and testing. This course targets an audience with prior programming experience, and that prior experience is leveraged so material can be covered in greater depth. (Stanford)

CS 106B: Programming Abstractions (35) intro

Abstraction and its relation to programming. Software engineering principles of data abstraction and modularity. Object-oriented programming, fundamental data structures (such as stacks, queues, sets) and data-directed design. Recursion and recursive data structures (linked lists, trees, graphs). Introduction to time and space complexity analysis. Uses the programming language C++ covering its basic facilities. (Stanford)

CS 106E: Exploration of Computing (3) intro

This course, designed for the non-computer scientist, will provide students with a solid foundation in the concepts and terminology behind computers, the Internet, and software development. It will give you better understanding and insight when working with technology. It will be particularly useful to future managers and PMs who will work with or who will lead programmers and other tech workers. But it will be useful to anyone who wants a better understanding of tech concepts and terms. We'll start by covering the foundations of Computer Hardware, the CPU, Operating Systems, Computer Networks, and the Web. We will then use our foundation to explore a variety of tech-related topics including Computer Security (how computers are attacked and defensive measures that can be taken); Cloud Computing, Artificial Intelligence, Software Development, Human-Computer Interaction, and Computer Theory. (Stanford)

CS 106L: Standard C++ Programming Laboratory (1) intro

This class explores features of the C++ programming language beyond what's covered in CS 106B. Topics include core C++ language features (e.g. const-correctness, operator overloading, templates, move semantics, and lambda expressions) and standard libraries (e.g. containers, algorithms, and smart pointers). (Stanford)

CS 106M: Enrichment Adventures in Programming Abstractions (1) intro

This enrichment add-on is a companion course to CS 106B to explore additional topics and go into further depth. Specific topics to be announced per-quarter; past topics have included search engines, pattern recognition, data compression/encryption, error correction, digital signatures, and numerical recipes. (Stanford)

CS 106S: Coding for Social Good (1) intro

Survey course on applications of fundamental computer science concepts from CS 106B to problems in the social good space (such as health, trust & safety, government, security, education, and environment). Each week consists of in-class activities designed and delivered by student instructors. Introduces students to JavaScript and the basics of web development. Some of the topics we will cover include mental health chatbots, tumor classification with basic machine learning, sentiment analysis of tweets on refugees, the basics of open source software, and principles of cybersecurity. (Stanford)

CS 108: Object-Oriented Systems Design (34) intro

Software design and construction in the context of large OOP libraries. Taught in Java. Topics: OOP design, design patterns, testing, graphical user interface (GUI) OOP libraries, software engineering strategies, approaches to programming in teams. (Stanford)

CS 193Q: Introduction to Python Programming (1) intro

CS 193Q teaches basic Python programming with a similar end-condition to CS 106AP: strings, lists, numbers, dicts, loops, logic, functions, testings, decomposition and style, and modules. CS 193Q assumes knowledge of some programming language, and proceeds by showing how each common programming idea is expressed in Python. CS 193Q moves very quickly, meeting 3 times for 4 hours for a total of 12 hours which is a mixture of lecture and lab time. (Stanford)

CS 194A: Android Programming Workshop (1) intro

Learn basic, foundational techniques for developing Android mobile applications and apply those toward building a single or multi page, networked Android application. (Stanford)

CS 298: Seminar on Teaching Introductory Computer Science (EDUC 298) (1) intro

Faculty, undergraduates, and graduate students interested in teaching discuss topics raised by teaching computer science at the introductory level. (Stanford)

CS 100BACE: Problem-solving Lab for CS 106B (1) intro

Additional problem solving practice for the introductory CS course CS 106B. Sections are designed to allow students to acquire a deeper understanding of CS and its applications, work collaboratively, and develop a mastery of the material. Limited enrollment, permission of instructor required. Concurrent enrollment in CS 106B required. (Stanford)

CPSC 021: Introduction to Computer Science (1) intro

This course presents fundamental ideas in computer science while building skills in software development. Students implement algorithms as programs in a high-level programming language. Introducing object-oriented programming and data structures allows students to construct correct, understandable, and efficient algorithms. CPSC 031 and CPSC 035 present a deeper coverage of these topics. CPSC 021 is appropriate for all students who want to be able to write programs. It is the usual first course for computer science majors and minors. Students with Advanced Placement credit or extensive programming experience may be able to place out of this course. Students who think that they may fall into this latter category should consult with any computer science faculty member. (Swarthmore)

CPSC 035: Data Structures and Algorithms (1) intro

This course completes the broad introduction to computer science begun in CPSC 021. It provides a general background for further study in the field. Topics to be covered include object-oriented programming in C++, advanced data structures (trees, priority queues, hash tables, graphs, etc.) and algorithms, and software design and verification. Students will be expected to complete several programming projects illustrating the concepts presented. (Swarthmore)

CSCE 110: Programming I (4) intro

Basic concepts in using computation to enhance problem solving abilities; understanding how people communicate with computers, and how computing affects society; computational thinking; representation of data; analysis of program behavior; methods for identifying and fixing errors in programs; understanding abilities and limitation of programs; development and execution of programs. (Texas A&M)

CSCE 111: Introduction to Computer Science Concepts and Programming (4) intro

Computation to enhance problem solving abilities; understanding how people communicate with computers, and how computing affects society; computational thinking; software design principles, including algorithm design, data representation, abstraction, modularity, structured and object oriented programming, documentation, testing, portability, and maintenance; understanding programs’ abilities and limitations; development and execution programs. (Texas A&M)

CSCE 120: Program Design and Concepts (3) intro

Extension of prior programming knowledge and creation of computer programs that solve problems; use of the C++ language; application of computational thinking to enhance problem solving; analysis of, design of and implementation of computer programs; use of basic and aggregate data types to develop functional and object oriented solutions; development of classes that use dynamic memory and avoid memory leaks; study of error handling strategies to develop more secure and robust programs. (Texas A&M)

CSCE 121: Introduction to Program Design and Concepts (4) intro

Computation to enhance problem solving abilities; computational thinking; understanding how people communicate with computers, how computing affects society; design and implementation of algorithms; data types, program control, iteration, functions, classes, and exceptions; understanding abstraction, modularity, code reuse, debugging, maintenance, and other aspects of software development; development and execution of programs. (Texas A&M)

CSCE 206: Structured Programming in C (4) intro

Basic concepts, nomenclature and historical perspective of computers and computing; internal representation of data; software design principles and practice; structured and object-oriented programming in C; use of terminals, operation of editors and executions of student-written programs. (Texas A&M)

CSCE 221: Data Structures and Algorithms (4) intro

Specification and implementation of basic abstract data types and their associated algorithms including stacks, queues, lists, sorting and selection, searching, graphs, and hashing; performance tradeoffs of different implementations and asymptotic analysis of running time and memory usage; includes the execution of student programs written in C++. (Texas A&M)

CS 11: Introduction to Computer Science (4) intro

The study of computer science centers on two complementary aspects of the discipline. First, computer science is fundamentally concerned with the problem-solving methodologies it derives from its foundational fields: the design principles of engineering, mathematical theory, and scientific empirical study. Second, these methodologies are applied in the complex context of a modern day computing system. In this course we will address both of these important aspects. As a means for developing your design skills, we will discuss the fundamental features of a high level, general purpose programming language -- namely C++-- and learn how to use it as a tool for problem solving. We will also consider the performance of solutions, and how to apply both analytical and empirical assessment techniques. Finally, we will explore the Unix operating system as a context for problem solving. (Additional 2 hr weekly lab time scheduled at first class meeting.) (Tufts)

CS 15: Data Structures (4) intro

A second course in computer science. Data structures and algorithms are studied through major programming projects in the C++ programming language. Topics include linked lists, trees, graphs, dynamic storage allocation, and recursion. (Tufts)

CY105: Computing Fundamentals (3) intro

This course provides an introduction to the fundamentals of computing and Cyberspace. The course presents basic program design and construction techniques, with consideration given to principles of software engineering. Problem solving using computing devices as tools is a central theme throughout the course as students employ various design methodologies. Students utilize an integrated development environment and contemporary application software. Emphasis is placed on critical thinking, creativity, and learning how to learn. Students are introduced to legal, ethical, professional, and security issues and the challenges, opportunities, and attributes of the cyber domain. (West Point)

CY155: Explorations in Computing Fund (3) intro

This course provides a more advanced opportunity to explore the fundamentals of computing and Cyberspace. The course presents basic program design and construction techniques, with consideration given to principles of software engineering. Problem solving using computing devices as tools is a central theme throughout the course as students employ various design methodologies. Students utilize an integrated development environment and contemporary application software. Emphasis is placed on critical thinking, creativity, and learning how to learn. Students are introduced to legal, ethical, professional, and security issues and the challenges, opportunities, and attributes of the cyber domain. (West Point)

CY300: Programming Fundamentals (3) intro

Cadets learn fundamental computing concepts that will allow them to design, build and test small to medium programs using a high-level programming language. Key concepts include applying appropriate aspects of a structured problem solving process, applying a standardized design notation such as the Unified Modeling Language (UML) to communicate their design, and iteratively testing their program. (West Point)

CS384: Data Structures (3) intro

This course is designed to build on the cadet's basic programming knowledge. Major emphasis is placed on object-based design, programming methodology, algorithms and algorithm analysis, data structures, and abstract data types as tools for the analysis, design, and implementation of software modules to meet specified requirements. Cadets will learn and employ several well-known algorithms and data structures. Techniques of searching, sorting, recursion, and hashing will be examined. Data structures such as sets, heaps, linked lists, stacks, queues, and trees will be covered. A block-structured programming language reflecting comprehensive support for good software engineering principles will be the foundation of application-oriented exercises. Cadets will design software solutions by employing problem decomposition and selecting the appropriate algorithms and abstract data types. (West Point)

CS 61A: The Structure and Interpretation of Computer Programs (4) intro

An introduction to programming and computer science focused on abstraction techniques as means to manage program complexity. Techniques include procedural abstraction; control abstraction using recursion, higher-order functions, generators, and streams; data abstraction using interfaces, objects, classes, and generic operators; and language abstraction using interpreters and macros. The course exposes students to programming paradigms, including functional, object-oriented, and declarative approaches. It includes an introduction to asymptotic analysis of algorithms. There are several significant programming projects. (Berkeley)

CS 61B: Data Structures (4) intro

Fundamental dynamic data structures, including linear lists, queues, trees, and other linked structures; arrays strings, and hash tables. Storage management. Elementary principles of software engineering. Abstract data types. Algorithms for sorting and searching. Introduction to the Java programming language. (Berkeley)

CS 61BL: Data Structures and Programming Methodology (4) intro

The same material as in 61B, but in a laboratory-based format. (Berkeley)

CS 61C: Great Ideas of Computer Architecture (Machine Structures) (4) intro

The internal organization and operation of digital computers. Machine architecture, support for high-level languages (logic, arithmetic, instruction sequencing) and operating systems (I/O, interrupts, memory management, process switching). Elements of computer logic design. Tradeoffs involved in fundamental architectural design decisions. (Berkeley)

CS C88C: Computational Structures in Data Science (3) intro

Development of Computer Science topics appearing in Foundations of Data Science (C8); expands computational concepts and techniques of abstraction. Understanding the structures that underlie the programs, algorithms, and languages used in data science and elsewhere. Mastery of a particular programming language while studying general techniques for managing program complexity, e.g., functional, object-oriented, and declarative programming. Provides practical experience with composing larger systems through several significant programming projects. (Berkeley)

CSE 6R: Introduction to Computer Science and Object-Oriented Programming: Python (4) intro

An introduction to computer science and programming using the Python language. The course will cover topics such as basic data types (e.g., integer, float, string), loops and iteration, basic data structures (e.g., list, set, dictionary), memory models, conditional statements, recursion, basic algorithm time complexity analysis, class design, and inheritance. (UCSD)

CSE 8A: Introduction to Programming and Computational Problem-Solving I (4) intro

Introductory course for students interested in computer science and programming. Basics of programming including variables, conditionals, loops, functions/methods. Structured data storage such as arrays/lists and dictionaries, including data mutation. Hands-on experience with designing, writing, hand-tracing, compiling or interpreting, executing, testing, and debugging programs. Students solve relevant computational problems using a high-level programming language. CSE 8A is part of a two-course sequence (CSE 8A-B) that is equivalent to CSE 11. Students should take CSE 8B to complete the CSE 8A-B track. Students who have taken CSE 8B or CSE 11 may not take or receive credit for CSE 8A. Students may only receive credit for one of the following: BILD 62, COGS 18, CSE 8A, or CSE 6R. Recommended preparation: No prior programming experience is assumed, but comfort using computers is helpful. Students should consult the “CSE Course Placement Advice” web page for assistance in choosing which CSE course to take first. (UCSD)

CSE 8B: Introduction to Programming and Computational Problem-Solving II (4) intro

Introductory programming using an object-oriented approach with the Java programming language. Builds on basic programming constructs introduced in CSE 8A to introduce class design and use, interfaces, basic class hierarchies, recursion, event-based programming, error reporting with exceptions, and file I/O. Basics of command-line navigation for file management and running programs. Development, testing, and debugging of more complex programs. CSE 8B is part of a two-course sequence (CSE 8A-B) that is equivalent to CSE 11. No credit offered for CSE 8B if CSE 11 taken previously. Students may not receive credit for CSE 8B and CSE 11. Students should consult the “CSE Course Placement Advice” web page for assistance in choosing which CSE course to take first. (UCSD)

CSE 11: Introduction to Programming and Computational Problem-Solving: Accelerated Pace (4) intro

Accelerated introductory programming including an object-oriented approach. Covers basic programming topics from CSE 8A including variables, conditionals, loops, functions/methods, structured data storage, and mutation. Also covers topics from CSE 8B including the Java programming language, class design, interfaces, basic class hierarchies, recursion, event-based programming, and file I/O. Basics of command-line navigation for file management and running programs. Zero units of credit offered for CSE 11 if CSE 8B taken previously or concurrently. Recommended preparation: Significant prior programming experience (for example, high school AP CSA). Students should consult the “CSE Course Placement Advice” web page for assistance in choosing a first CSE course. (UCSD)

CSE 12: Basic Data Structures and Object-Oriented Design (4) intro

Use and implementation of basic data structures including linked lists, stacks, and queues. Use of advanced structures such as binary trees and hash tables. Object-oriented design including interfaces, polymorphism, encapsulation, abstract data types, pre-/post-conditions. Recursion. Uses Java and Java Collections. (UCSD)

CSE 42: Building and Programming Electronic Devices (2) intro

This course allows students to use what they learned in introductory programming courses to make things happen in the real world. Working in teams, students will first learn to program Arduino-based devices. (UCSD)

CSE 86: C++ for Java Programmers (2) intro

Helps the Java programmer to be productive in the C++ programming environment. Topics include the similarities and differences between Java and C++ with special attention to pointers, operator overloading, templates, the STL, the preprocessor, and the C++ Runtime Environment. (UCSD)

CSE 180: Biology Meets Computing (4) intro

Topics include an overview of various aspects of bioinformatics and will simultaneously introduce students to programming in Python. The assessments in the course represent various programming challenges and include solving diverse biological problems using popular bioinformatics tools. (UCSD)

CSE 180R: Biology Meets Computing (4) intro

Topics include an overview of various aspects of bioinformatics and will simultaneously introduce students to programming in Python. The assessments in the course represent various programming challenges and include solving diverse biological problems using popular bioinformatics tools. This will be a fully online class based on extensive educational materials and online educational platform Stepik developed with HHMI, NIH, and ILTI support. (UCSD)

CMPSC 16: Problem Solving with Computers I (4) intro

Fundamental building blocks for solving problems using computers. Topics include basic computer organization and programming constructs: memory CPU, binary arithmetic, variables, expressions, statements, conditionals, iteration, functions, parameters, recursion, primitive and composite data types, and basic operating system and debugging tools. (UCSB)

CMPSC 24: Problem Solving with Computers II (4) intro

Intermediate building blocks for solving problems using computers. Topics include intermediate object-oriented programming, data structures, object-oriented design, algorithms for manipulating these data structures and their run-time analyses. Data structures introduced include stacks, queues, lists, trees, and sets. (UCSB)

CMPSC 32: Object Oriented Design and Implementation (4) intro

Advanced topics in object-oriented computing. Topics include encapsulation, data hiding, inheritance, polymorphism, compilation, linking and loading, memory management, and debugging; recent advances in design and development tools, practices, libraries, and operating system support. (UCSB)

CS 101: Intro Computing: Engrg & Sci (3) intro

Fundamental principles, concepts, and methods of computing, with emphasis on applications in the physical sciences and engineering. Basic problem solving and programming techniques; fundamental algorithms and data structures; use of computers in solving engineering and scientific problems. Intended for engineering and science majors. (Illinois)

CS 124: Introduction to Computer Science I (3) intro

Basic concepts in computing and fundamental techniques for solving computational problems. Intended as a first course for computer science majors and others with a deep interest in computing. (Illinois)

CS 125: Introduction to Computer Science (4) intro

Basic concepts in computing and fundamental techniques for solving computational problems. Intended as a first course for computer science majors and others with a deep interest in computing. (Illinois)

CS 126: Software Design Studio (3) intro

Fundamental principles and techniques of software development. Design, documentation, testing, and debugging software, with a significant emphasis on code review. (Illinois)

CS 128: Introduction to Computer Science II (3) intro

Continuation of CS 124. More advanced concepts in computing and techniques and approaches for solving computational problems. (Illinois)

CS 225: Data Structures (4) intro

Data abstractions: elementary data structures (lists, stacks, queues, and trees) and their implementation using an object-oriented programming language. Solutions to a variety of computational problems such as search on graphs and trees. Elementary analysis of algorithms. (Illinois)

CS 242: Programming Studio (3) intro

Intensive programming lab intended to strengthen skills in programming. (Illinois)

CS 111: Introduction to Web Programming (4) intro

Project-based approach to learning computer programming by building interactive web pages using JavaScript and XHTML. Programming concepts including structured and object-oriented program design. (UO)

CS 122: Introduction to Programming and Problem Solving (4) intro

Computational problem solving, algorithm design, data structures, and programming using a multi-paradigm programming language. Introduces techniques for program design, testing, and debugging. (UO)

CS 210: Computer Science I (4) intro

Basic concepts and practices of computer science. Topics include algorithmic problem solving, levels of abstraction, object-oriented design and programming, software organization, analysis of algorithm and data structures. (UO)

CS 211: Computer Science II (4) intro

Basic concepts and practices of computer science. Topics include algorithmic problem solving, levels of abstraction, object-oriented design and programming, software organization, analysis of algorithm and data structures. (UO)

CS 212: Computer Science III (4) intro

Basic concepts and practices of computer science. Topics include algorithmic problem solving, levels of abstraction, object-oriented design and programming, software organization, analysis of algorithm and data structures. (UO)

CIS 1100: Introduction to Computer Programming (1) intro

Introduction to Computer Programming is the first course in our series introducing students to computer science. In this class you will learn the fundamentals of computer programming, with emphasis on applications in science and engineering. You will also learn about the broader field of computer science and algorithmic thinking, the fundamental approach that computer scientists take to solving problems. (Penn)

CIS 1200: Programming Languages and Techniques I (1) intro

A fast-paced introduction to the fundamental concepts of programming and software design. This course assumes some previous programming experience, at the level of a high school computer science class or CIS 1100. (If you got at least 4 in the AP Computer Science A or AB exam, you will do great.) No specific programming language background is assumed: basic experience with any language (for instance Java, C, C++, VB, Python, Perl, or Scheme) is fine. If you have never programmed before, you should take CIS 1100 first. (Penn)

CIS 1210: Programming Languages and Techniques II (1) intro

This is a course about Algorithms and Data Structures using the Java programming language. We introduce the basic concepts about complexity of an algorithm and methods on how to compute the running time of algorithms. Then, we describe data structures like stacks, queues, maps, trees, and graphs, and we construct efficient algorithms based on these representations. The course builds upon existing implementations of basic data structures in Java and extends them for the structures like trees, studying the performance of operations on such structures, and their efficiency when used in real-world applications. (Penn)

CSCI 102L: Fundamentals of Computation (2) intro

Fundamental concepts of algorithmic thinking as a primer to programming. Introduction to C++. (USC)

CSCI 103L: Introduction to Programming (4) intro

Basic datatypes, assignments, control statements (if, switch, for, while), input/output (printf, scanf, cin, cout), functions, arrays, structures, recursion, dynamic memory, file handling. Programming in C/C++. (USC)

CSCI 104L: Data Structures and Object Oriented Design (4) intro

Introduces the student to standard data structures (linear structures such as linked lists, (balanced) trees, priority queues, and hashtables), using the C++ programming language. (USC)

CTIN 289: Game Development Fundamentals (4) intro

Covers core skills for creating in a digital game engine, the role of prototyping in the game development and the use of version control systems. (USC)

CMPU 100: Programming with Data (1) intro

Introduces fundamentals of computer programming and data analysis. Students learn to write programs to collect, clean, transform, and visualize data from a variety of domains. Working on real-world problems and data sets, students also consider social issues surrounding data collection and analysis. This course is designed for students from any discipline who want to learn to use programming as a tool for data-driven discovery. No prior programming experience is required. A weekly laboratory period provides guided hands-on experience. The Department. (Vassar)

CMPU 101: Problem-Solving and Abstraction (1) intro

Introduces object-oriented software design, covering objects and classes, abstraction, encapsulation, inheritance, and polymorphism. Additional topics include recursion, unit testing, and error handling. Students who are thinking about the Computer Science major should take this course. A weekly laboratory period provides guided hands-on experience. The Department. (Vassar)

CMPU 102: Data Structures and Algorithms (1) intro

Explores ways to solve computational problems by organizing data in canonical data structures and associated algorithms, using an object-oriented programming language. Data structures that realize common abstract data types such as lists, queues, stacks, maps, and trees are studied in depth. Additionally, common algorithm design techniques and asymptotic analysis are introduced. A weekly laboratory period provides guided hands-on experience. The Department. (Vassar)

CMPU 144: Foundations of Data Science (1) intro

This course focuses on the development and practice of computational and inferential thinking. Students are introduced to the fundamentals of programming and inference. Students learn to write programs, create data visualizations, and work with real-world datasets, culminating in a final data analysis project. (Vassar)

CMPU 145: Foundations of Computer Science (1) intro

Uses the functional programming paradigm to illuminate the important connections between recursive data structures, recursive functions and (structural) induction. Other topics include: sets, logic and probability. Concepts are reinforced by regular assignments with mathematical and programming components. A weekly laboratory period provides guided hands-on experience. The Department. (Vassar)

CSE 131: Introduction to Computer Science (3) intro

An introduction to software concepts and implementation, emphasizing problem solving through abstraction and decomposition. Introduces processes and algorithms, procedural abstraction, data abstraction, encapsulation and object-oriented programming. Recursion, iteration and simple data structures are covered. Concepts and skills are mastered through programming projects, many of which employ graphics to enhance conceptual understanding. Java, an object-oriented programming language, is the vehicle of exploration. Active-learning sessions are conducted in a studio setting in which students interact with each other and the professor to solve problems collaboratively. (Washington U.)

CSE 132: Introduction to Computer Engineering (3) intro

This course introduces students to fundamental concepts in the basic operation of computers, ranging from desktops and servers to microcontrollers and handheld devices. Subjects include digital and analog input/output, sensing the physical world, information representation, basic computer architecture and machine language, time-critical computation, machine-to-machine communication and protocol design. Students will use both desktop systems and handheld microcontrollers for laboratory experiments. (Washington U.)

CSE 232: Programming Skills Workshop (1) intro

This course provides an overview of practical implementation skills. Topics include compilation and linking, memory management, pointers and references, using code libraries, testing and debugging. (Washington U.)

CSE 332S: Object-Oriented Software Development Laboratory (3) intro

Intensive focus on practical aspects of designing, implementing and debugging software, using object-oriented, procedural, and generic programming techniques. The course emphasizes familiarity and proficiency with a wide range of C++ language features through hands-on practice completing studio exercises and lab assignments, supplemented with readings and summary presentations for each session. (Washington U.)

CS 110: Computing in the Age of AI (1) intro

The rapid advancement of artificial intelligence (AI) is transforming the way we work, interact, and make decisions. AI is integrated into applications and devices that are woven into our daily lives. How does AI work? What impact will AI have on individuals, communities, and our global society? This course aims to provide students with the knowledge and skills to become informed digital citizens in the age of AI, ready to navigate the digital landscape. Students will gain fundamental technical understanding of how computers, the Web, and AI work, and will study three programming languages: HTML5, CSS, and JavaScript. Students will also examine and discuss societal and ethical issues related to the Web and AI technologies, and consider responsible and future use of these technologies. (Wellesley)

CS 110L: Lab: Computing in the Age of AI (0) intro

CS 110L/MAS 110L is a required co-requisite lab for CS 110/MAS 110. (Wellesley)

CS 111: Comp Program & Prob Solving (1) intro

An introduction to problem-solving through computer programming. Students learn how to read, modify, design, debug, and test algorithms that solve problems. Programming concepts include control structures, data structures, abstraction, recursion, and modularity. Students explore these concepts in the context of interactive programs, data processing, and graphics or audio, using the Python programming language. (Wellesley)

CS 111L: Lab: Computer Programming & Problem Solving (0) intro

Accompanying required laboratory for CS 111. (Wellesley)

CS 111X: Computer Programming and Problem Solving (1) intro

An introduction to problem-solving through computer programming. Students learn how to read, modify, design, debug, and test algorithms that solve problems. Programming concepts include control structures, data structures, abstraction, recursion, and modularity. Students explore these concepts in the context of interactive programs, data processing, and graphics or audio, using the Python programming language. Students in this section will complete self-directed weekly labs. This section is intended for students who have some previous programming experience, but would benefit from more before taking CS 230. Students unsure about whether to take CS 111, CS 111X, or CS 230 as their first Wellesley CS course should complete the CS placement questionnaire. (Wellesley)

CS 112: Intro Computing for the Sciences (1) intro

An introduction to problem-solving through computer programming with special focus on application to problems relevant to physics, chemistry, and biology. Students learn how to read, modify, design, debug, and test algorithms that solve problems. Programming concepts include control structures, problem solving strategies, abstraction, recursion, and modularity. Students explore these concepts in the context of interactive programs, data processing, and graphical and numerical analysis, using the Python programming language. Students are required to attend a 2.5-hour lab where they will apply concepts learned in lecture to study topics at the intersection of chemistry and physics. Topics might include: chemical kinetics, numerical integration, molecular dynamics, computational biology, Monte Carlo techniques, and basic statistical analysis. (Wellesley)

CS 200: OO Programming Studio in Java (1) intro

CS200 introduces students to Java, and the Object Oriented Model of programming with hands-on instruction and experience, using active learning pedagogical approaches. Students will gain knowledge and reinforcement in fundamental programming and programming-related skills, including problem decomposition into smaller and more manageable sub-problems, designing in the Object Oriented Model, programming in Java, practicing fundamental constructs like conditionals, looping, usage of basic Data Structures, as well as debugging and testing techniques. In addition, attention will be paid in developing skills around project management, pair and team work, and identifying and evaluating reliable resources for the task at hand. With successful completion of this course, students are expected to be independent programmers and learners, and effective team members. (Wellesley)

CS 221: Digital Worlds for Gaming (1) intro

Digital games visualize compelling worlds that can resemble real-life environments and imagine other-worldly spaces. These virtual realms frame our experience of games and their design dramatically impacts our interpretation of their narratives and mechanics. Designers code environments to shape player agency and weave complex relationships between game characters. This course will teach students to create digital worlds and critically assess them as politically rich spaces that convey meaning. Students will build both 2D and 3D digital environments, coding elements such as interactivity and non-player entities, crafting game experiences that tell meaningful stories. CS221 continues to explore the Unity Game Engine and topics introduced by CS121, but enrollment is suitable for any student with 100-level coding experience and an interest in game design. (Wellesley)

CS 230: Data Structures (1) intro

An introduction to techniques and building blocks for organizing large programs. Topics include: modules, abstract data types, recursion, algorithmic efficiency, and the use and implementation of standard data structures and algorithms, such as lists, trees, graphs, stacks, queues, priority queues, tables, sorting, and searching. Students become familiar with these concepts through weekly programming assignments using the Java programming language. (Wellesley)

CS 230P: Data Structures (1) intro

An introduction to techniques and building blocks for organizing large programs. Topics include: modules, abstract data types, recursion, algorithmic efficiency, and the use and implementation of standard data structures and algorithms, such as lists, trees, graphs, stacks, queues, priority queues, tables, sorting, and searching. Students become familiar with these concepts through *additional self-driven weekly programming practice using the Java programming language. (Wellesley)

CS 230PL: Lab: Data Structures (0) intro

This is a required co-requisite laboratory for CS 230P. (Wellesley)

CS 230X: Data Structures (1) intro

An introduction to techniques and building blocks for organizing large programs. Topics include: modules, abstract data types, recursion, algorithmic efficiency, and the use and implementation of standard data structures and algorithms, such as lists, trees, graphs, stacks, queues, priority queues, tables, sorting, and searching. Students become familiar with these concepts through weekly programming assignments using the Java programming language. (Wellesley)

COMP 112: Introduction to Programming (1) intro

The course will provide an introduction to a modern high-level programming language including a discussion of input/output, basic control structures, types, functions, and classes. The lectures will also discuss a variety of algorithms as well as program design issues. (Wesleyan)

COMP 113: Bioinformatics Programming (1) intro

An introduction for life science students with little or no prior programming experience, this course will introduce the fundamental concepts and mechanisms of computer programs using a language (Perl or Python) and examples (sequence matching and manipulation, database access, output parsing, etc.) frequently encountered in the use and development of informatics software. (Wesleyan)

COMP 114: How to talk to machines (1) intro

How do we tell robots and computers how to do what they do? Getting a handle on this question is the goal of this course. Since telling a device how to do something depends a lot on what that device can do, along the way we will learn a bit about what is 'in the box.' We will start with the kind of programming one might use to instruct a robot how to interact with the world around it. That will lead us to the Turing machine, a beautiful mathematical model of a computer. We will adapt that model to something that is closer to how most computer systems today are designed. We will end with an introduction to high-level programming, learning the fundamentals of programming in a language such as Python or Java. The goal of the course is to understand not just programming, but how computers are designed, and how those designs are reflected in the way we program them. After passing this course, students will have a basic knowledge of programming and how a computer works. (Wesleyan)

COMP 115: How to design programs (1) intro

In this course, students will learn to systematically design programs, going from a problem statement to a well-organized solution in a step-by-step fashion. We will apply these program design skills to many applications within computer science and in other disciplines. Students will develop their mathematical skills, because we will use a symbolic view of computation that explains the process of running a program as simple manipulations of its text. Students will also develop their technical reading and writing skills, such as understanding complex problem descriptions and precisely articulating the design of solutions. No prior experience with programming or computer science is expected. (Wesleyan)

COMP 211: Computer Science I (Gateway) (1) intro

This is the first course in a two-course sequence (COMP211-212) that is the gateway to the computer science major. It is intended for prospective computer science majors and others who want an in-depth understanding of programming and computer science. Topics to be covered in COMP211-212 include an introduction to the fundamental ideas of programming in imperative and functional languages, correctness and cost specifications, and proof techniques for verifying specifications. Specifics such as choice of programming language, which topics are covered in which semesters, etc., will vary according to the tastes of the faculty offering the courses. (Wesleyan)

COMP 212: Computer Science II (Gateway) (1) intro

This is the second course in a two-course sequence (COMP211-212) that is the gateway to the computer science major. It is intended for prospective computer science majors and others who want an in-depth understanding of programming and computer science. Topics to be covered in COMP211-212 include an introduction to the fundamental ideas of programming in imperative and functional languages, correctness and cost specifications, and proof techniques for verifying specifications. Specifics such as choice of programming language, which topics are covered in which semesters, etc., will vary according to the tastes of the faculty offering the courses. (Wesleyan)

CSCI 134: Introduction to Computer Science (1) intro

This course introduces students to the science of computation by exploring the representation and manipulation of data and algorithms. We organize and transform information in order to solve problems using algorithms written in a modern object-oriented language. Topics include organization of data using objects and classes, and the description of processes using conditional control, iteration, methods and classes. We also begin the study of abstraction, self-reference, reuse, and performance analysis. While the choice of programming language and application area will vary in different offerings, the skills students develop will transfer equally well to more advanced study in many areas. In particular, this course is designed to provide the programming skills needed for further study in computer science and is expected to satisfy introductory programming requirements in other departments. (Williams)

CSCI 136: Data Structures and Advanced Programming (1) intro

This course builds on the programming skills acquired in Computer Science 134. It couples work on program design, analysis, and verification with an introduction to the study of data structures. Data structures capture common ways in which to store and manipulate data, and they are important in the construction of sophisticated computer programs. Students are introduced to some of the most important and frequently used data structures: lists, stacks, queues, trees, hash tables, graphs, and files. Students will be expected to write several programs, ranging from very short programs to more elaborate systems. Emphasis will be placed on the development of clear, modular programs that are easy to read, debug, verify, analyze, and modify. (Williams)

CPSC 100: Introduction to Computing and Programming (1) intro

Introduction to the intellectual enterprises of computer science and to the art of programming. Students learn how to think algorithmically and solve problems efficiently. Topics include abstraction, algorithms, data structures, encapsulation, resource management, security, software engineering, and web development. Languages include C, Python, SQL, and JavaScript, plus CSS and HTML. Problem sets inspired by real-world domains of biology, cryptography, finance, forensics, and gaming. No previous programming experience required. Open to students of all levels and majors. (Yale)

CPSC 110: Python Programming for Humanities and Social Sciences (1) intro

Introduction to computer science and Python programming with domain-specific applications. Students learn how to think algorithmically and solve problems efficiently. Topics include abstraction, algorithms, data structures, web development, and statistical tools. Students learn to apply computing techniques in the fields of social sciences & humanities by analyzing data. No previous programming experience is required. This course is intended for students of social sciences & humanities majors. (Yale)

CPSC 112: Introduction to Programming (1) intro

Development on the computer of programming skills, problem-solving methods, and selected applications. No previous experience with computers necessary. (Yale)

CPSC 201: Introduction to Computer Science (1) intro

Introduction to the concepts, techniques, and applications of computer science. Topics include computer systems (the design of computers and their languages); theoretical foundations of computing (computability, complexity, algorithm design); and artificial intelligence (the organization of knowledge and its representation for efficient search). Examples stress the importance of different problem-solving methods. After CPSC 112 or equivalent. (Yale)

CPSC 223: Data Structures and Programming Techniques (1) intro

Topics include programming in C; data structures (arrays, stacks, queues, lists, trees, heaps, graphs); sorting and searching; storage allocation and management; data abstraction; programming style; testing and debugging; writing efficient programs. After CPSC 200, 201 or passing an exam based on CPSC 201 content. (Yale)

CPSC 327: Object-Oriented Programming (1) intro

Object-oriented programming as a means to designing and writing efficient, reliable, modular, and reusable code. Covers core concepts and features of object-oriented languages (classes, inheritance, composition, encapsulation, polymorphism, and exceptions) as well as the use of object-oriented design patterns (iterator, decorator, strategy, adapter, observer, etc.). (Yale)