Principles of Computational Thinking for Engineers#
Description#
Engineering practice increasingly relies on computational tools and data analysis approaches. This one-semester course introduces computational thinking into engineering analysis. We integrate data science and statistics, artificial intelligence, and mathematical modeling approaches into the context of contemporary problems in the design and analysis of processes, products, and systems. The course is agnostic to platforms and tools; we’ll focus on paradigms, not syntax. However, we’ll use the Julia programming language and its associated toolchain when transitioning from idea to implementation. In addition, we’ll use cloud computing resources for course materials, assignments, and projects. Weekly labs provide guided practice on the computer, with teaching staff present. Course assignments use data sets and examples to develop fluency and understanding of real-life problems.
CHEME 4800 will co-meet with CHEME 5800. Students in CHEME 4800 will attend the same lectures and lab sections and complete the same problem sets as CHEME 5800. However, students in CHEME 5800 will have a significantly more in-depth team project than the CHEME 4800 students.
Times, places and websites#
Outcomes#
Upon completion of this course, students will be able to:
Demonstrate mastery of fundamental software engineering paradigms, data structures, common programming idioms, and algorithms.
Analyze scientific, engineering, and financial data sets using tools from data science/statistics and machine learning (ML)
Identify and test quantitative models of process and product performance using real-time dynamic and static data sets.
Demonstrate mastery of quantitative decision-making and risk management approaches in the context of a process, product, or system design.
Topics#
Lectures are organized into units, each having roughly four weeks of class time
Schedule#
The lecture, lab and problem set schedule can be viewed at (requires Cornell login): lecture, lab and problem set schedule )
Grading#
We expect this course to draw from a spectrum of students, including “those less comfortable with computing,” “those more comfortable with computing,” and those in between. However, what ultimately matters is not where you end up relative to your classmates but where you are relative to yourself.
Each student’s final grade is individually determined at the end of the semester based on their performance in the following components (percentages subject to change):
Percentage |
Component |
|---|---|
10% |
Participation. Course participation (code reviews, questions and TA/course evaluations) will be an important component of the course. Participation opportunities will be identified throughout the semester. |
40% |
Problem sets. Approximately 10 problem sets will be administered over the semester. Problem sets will be distributed via Canvas (typically delivered on Friday afternoons and due one-week later). Problem sets can be completed in teams. |
20% |
Practicum. One take-home, practicum will be distributed. The distribution date will be announced ahead of time, and once distributed, students will have a specified number of hours (at least 36 hours) to complete the practicum. |
30% |
Final project. Development of a research project by each student (semester long with additional emphasis during the final 5 weeks of the course). The projects will conclude with a written report and an oral presentation to the class near the end of the semester. The final written reports will be due on the University assigned date for final projects. |
Grading details#
Problem sets, practicum, and the final project are evaluated using correctness as the primary criteria. However, in some cases, design and style will also be considered in assigning attainment levels.
The course is not graded on a curve. The course does not have pre-determined cutoffs for final grades. Those less comfortable and somewhere in between with computing are not disadvantaged compared to those more comfortable because of the mastery-based structure.
This is a mastery-based course. Thus, you will have as many resubmissions as required on all course assignments (excluding the project) to achieve your desired level of attainment. However, to be eligible for the redo policy, you must submit your initial attempt at the assignment, i.e., problem set or prelim, etc, by the posted deadline using the proper submission procedure. If you fail to do this, you will receive a zero for the assignment, which will be locked.
Course policies and procedures#
Students must know and abide by Cornell’s Code of Academic Integrity. You may discuss problem sets with classmates, but all submitted work should be yours. Take-home exams must be completed individually without the help of students, teaching assistants, faculty, and other sources. Please review Cornell’s academic integrity policy
The course will officially support numerical computing in various programming languages (open source and platform agnostic). We’ll use Visual Studio Code (VSCode) as our Integrated Development Environment (IDE).
Disabilities statement#
If you have a disability-related need for reasonable academic adjustments in this course, please provide Professor Varner with an accommodation letter from Student Disability Services. Students are expected to give two weeks’ notice of the need for accommodations.
Diversity statement#
We aspire to create an environment for learning, intellectual discourse, and professional and social interactions where everyone feels welcome and valued. We recognize all course participants as responsible adults with differing perspectives based partly on their unique experiences. We espouse the broader mission and values of the Smith School.