Programming for Engineers

Course Description

EGN3214 – Programming for Engineers is a 3-credit-hour upper-division engineering course that develops competency in Python programming for engineering problem-solving. The course is structured in two phases: the first half develops Python programming foundations (syntax, data structures, control flow, functions, file I/O, plotting, scientific libraries) at a level appropriate for engineering students; the second half applies these skills to real engineering problems and to the integration of programming into engineering workflows. The course explicitly incorporates AI-assisted coding tools (such as GitHub Copilot, ChatGPT, Claude, and similar) as core working tools rather than as add-ons — reflecting the substantial shift in programming education and engineering practice toward AI-integrated workflows.

EGN3214 is positioned as a junior-level course, building on whatever introductory programming exposure students received in their first-year engineering courses. The course extends programming literacy from "I can write a script" to "I can use programming as a primary engineering problem-solving tool, with effective AI assistance, on real engineering problems." Coursework typically combines lecture and example-based instruction with extensive hands-on programming projects, often including capstone-style projects analyzing real engineering data or solving real engineering analytical problems.

EGN3214 is offered at a single Florida institution. As a single-institution course, the specific syllabus reflects that institution's program emphasis; the description here characterizes the course as offered, but students at other institutions seeking similar content should consult course offerings at the relevant institution. EGN3214 transfers per SCNS articulation policy where the receiving institution accepts it; receiving institutions may apply transfer credit to comparable programming or computational engineering requirements.

Learning Outcomes

Required Outcomes

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

Phase 1: Python Programming Foundations

• Apply Python language fundamentals, including data types (int, float, str, bool, None); variables and assignment; basic operators; type conversion; the Python interpreter and the script-vs-interactive distinction.
• Apply Python data structures, including lists, tuples, dictionaries, and sets; the appropriate choice of data structure for a problem; common operations on each.
• Apply control flow, including conditional statements (if, elif, else); loops (for, while); break and continue; loop comprehensions (list, dict, set comprehensions) at intermediate level.
• Apply functions, including function definition, parameters (positional, keyword, default values, *args, **kwargs); return values; scope (local, global, nonlocal); the principle of single responsibility; lambda functions for short functional programming.
• Apply file I/O, including reading and writing text files; reading and writing CSV files; introductory work with structured data formats (JSON); the with-statement context manager.
• Apply error handling, including the try-except pattern; common exception types; the use of exceptions for graceful failure; raising exceptions appropriately.
• Apply NumPy for engineering numerical computation, including array creation; element-wise operations; broadcasting; array indexing and slicing; common NumPy functions (linear algebra, statistics, mathematical functions); the relationship between NumPy arrays and Python lists.
• Apply matplotlib for engineering data visualization, including line plots, scatter plots, bar charts, histograms, contour plots, 3D plots; the customization of plots (titles, labels, legends, colors, styles); the production of publication-quality figures.
• Apply pandas at introductory level, including DataFrame creation; reading data from CSV/Excel; basic data manipulation; integration with NumPy and matplotlib.
• Apply module organization and reuse, including writing reusable functions in modules; importing modules; managing project files; the basics of code organization for engineering projects.
• Apply introductory object-oriented programming (OOP) at conceptual level, including classes, instances, methods, and attributes; the engineering use of classes for representing engineering objects (a Beam class, a Sensor class, etc.).

Phase 2: Engineering Problem-Solving with Python

• Apply numerical methods using SciPy and NumPy, including root finding (scipy.optimize.fsolve, scipy.optimize.bisect); numerical integration (scipy.integrate.quad, simpson, trapezoid); numerical solution of ODEs (scipy.integrate.solve_ivp); linear algebra (numpy.linalg, scipy.linalg).
• Apply engineering data analysis, including the loading and cleaning of engineering data; descriptive statistics; visualization for engineering insight; the integration of pandas, NumPy, and matplotlib in typical engineering data workflows.
• Apply engineering simulation and modeling, including the implementation of engineering models (mechanical, electrical, thermal, fluid, chemical) in Python; the simulation of dynamic systems; the comparison of simulation results with analytical solutions or experimental data.
• Apply introductory machine learning using scikit-learn, including supervised learning at conceptual level (regression, classification); model evaluation; the appropriate use in engineering contexts.
• Apply engineering automation and workflow integration, including the automation of repetitive engineering tasks; the integration of Python with engineering tools (CAD APIs where supported, simulation software, instrument control); the building of small engineering tools and dashboards.
• Apply introductory hardware integration (where included), including basic interfacing with sensors, microcontrollers (Arduino, Raspberry Pi at introductory level), and data acquisition systems.
• Apply version control with Git at introductory level, including local repository creation; commit workflow; branching and merging at conceptual level; the use of GitHub for engineering project version control.

AI-Assisted Engineering Programming (Integrated Throughout)

• Apply AI-assisted code generation effectively, including the use of GitHub Copilot, ChatGPT, Claude, and comparable AI tools as engineering programming assistants; the formulation of effective prompts for code generation; the iteration between AI-generated code and human review.
• Apply AI-assisted code analysis and debugging, including the use of AI tools to explain unfamiliar code, suggest improvements, identify bugs, and propose alternative approaches; the development of judgment about when to accept AI suggestions and when to override.
• Apply responsible AI integration in engineering programming, including the verification of AI-generated code (it works, it is correct, it is appropriate); the recognition of AI failure modes (subtle bugs, hallucinated APIs, incorrect engineering context); the maintenance of engineering judgment as primary; ethical considerations in AI use.
• Apply AI-assisted engineering analysis, including the use of AI tools to support engineering problem formulation, methodology selection, and result interpretation; the boundaries of AI assistance for engineering decisions.
• Develop professional judgment about AI integration, including the recognition that engineering professionals must understand the work they sign off on, regardless of who or what wrote the underlying code; the importance of being able to read and evaluate AI-generated code, not just generate it; the engineer's continuing accountability for AI-assisted output.

Optional Outcomes

• Apply introductory deep learning using PyTorch or TensorFlow at conceptual level for engineering applications.
• Apply web-based engineering applications, including Flask or Streamlit for engineering tool deployment.
• Apply cloud computing at introductory level for engineering computation (AWS, Azure, GCP).
• Apply high-performance computing at conceptual level (parallelism with multiprocessing, vectorization with NumPy).
• Apply engineering API development, including the creation of REST APIs for engineering tools.

Major Topics

Required Topics

Phase 1: Python Foundations

• The Python Programming Environment: The Python interpreter; running Python (interactive vs. script); IDEs (VS Code, PyCharm, Spyder); Jupyter notebooks; package management with pip and conda; virtual environments; the Python ecosystem for engineering.
• Python Language Fundamentals: Data types (int, float, complex, str, bool, None); variables and assignment; operators (arithmetic, comparison, logical, bitwise); type conversion; the dynamic typing system.
• Control Flow: Conditional statements (if/elif/else); loops (for, while); break and continue; the range() function; iteration over data structures.
• Data Structures: Lists (mutable, ordered); tuples (immutable, ordered); dictionaries (key-value, hash-based); sets (unordered, unique); the appropriate choice of structure for a problem; common operations on each.
• List Comprehensions and Functional Patterns: List comprehensions ([x**2 for x in range(10)]); dict comprehensions; set comprehensions; map, filter, lambda functions; the readability advantages of comprehensions over explicit loops.
• Functions: Function definition; parameters (positional, keyword, default, *args, **kwargs); return values; scope (local, global, nonlocal); recursion at introductory level; lambda (anonymous) functions; the principle of single responsibility.
• Modules and Code Organization: The import statement; standard library modules (math, os, random, datetime); installing packages with pip; writing custom modules; organizing engineering projects.
• File I/O: Reading and writing text files (open, read, write, close); the with-statement; reading CSV files (with the csv module and with pandas); writing CSV; introduction to JSON for structured data.
• Error Handling: Common exception types (ValueError, TypeError, FileNotFoundError, KeyError, IndexError); the try-except pattern; the try-except-else-finally pattern; raising exceptions; the engineering value of graceful failure.
• NumPy: Array creation (np.array, np.zeros, np.ones, np.linspace, np.arange); element-wise operations; broadcasting; array indexing and slicing (including boolean indexing); reshape and transpose; common functions (linear algebra in np.linalg, statistics in np.mean/np.std/np.var, mathematical functions); the comparison with Python lists.
• matplotlib: The pyplot interface; line plots; scatter plots; bar charts; histograms; subplots; the customization of plots (xlabel, ylabel, title, legend, grid, color, marker, linestyle); saving figures; the production of publication-quality figures.
• pandas — Introduction: The Series and DataFrame; reading data (read_csv, read_excel); basic indexing and slicing; descriptive statistics; filtering; sorting; the integration with NumPy and matplotlib.
• Object-Oriented Programming — Introduction: Classes and instances; the __init__ method; attributes and methods; encapsulation at conceptual level; the engineering use of classes (a Beam class with cross-section attributes and stress-calculation methods, a Sensor class, etc.); inheritance at introductory level.

Phase 2: Engineering Applications

• Numerical Methods with SciPy: Root finding (scipy.optimize.fsolve, bisect, brentq); numerical integration (scipy.integrate.quad, simpson, trapezoid, fixed_quad); numerical ODE solution (scipy.integrate.solve_ivp); linear algebra (numpy.linalg.solve, eig, inv; scipy.linalg for advanced).
• Curve Fitting and Regression: Linear regression (numpy.polyfit, scipy.stats.linregress); polynomial regression; nonlinear curve fitting (scipy.optimize.curve_fit); residuals analysis; engineering applications.
• Engineering Data Analysis: Loading engineering data (CSV, Excel, time series); cleaning data (handling missing values, outlier detection); descriptive analysis; visualization for engineering insight; the typical engineering data analysis workflow.
• Engineering Simulation: The implementation of engineering models in Python (mechanical systems, electrical circuits, thermal systems, fluid systems); time-stepping simulation; the comparison of simulation with analytical solutions; the comparison with experimental data.
• Introductory Machine Learning: The supervised vs. unsupervised distinction; using scikit-learn for regression and classification at introductory level; train-test split; model evaluation metrics; the appropriate use in engineering contexts; the recognition of when traditional engineering analysis is more appropriate than ML.
• Engineering Automation: The automation of repetitive engineering tasks (data processing pipelines, report generation, parameter sweeps); the building of engineering tools; the principles of useful engineering tool design (clarity, reliability, maintainability).
• Hardware Integration (Where Included): Basic sensor reading; microcontroller programming (Arduino with Python via CircuitPython or PySerial; Raspberry Pi); data acquisition; the engineering applications.
• Version Control with Git and GitHub: Local Git basics (init, add, commit, log, diff); branching and merging at conceptual level; remote repositories on GitHub; the engineering value of version control.

AI Integration (Threaded Throughout)

• The Modern Programming Workflow: The shift in programming practice toward AI-integrated workflows; the role of AI tools as collaborators rather than replacements; the engineering value of effective AI integration.
• AI-Assisted Code Generation: GitHub Copilot, ChatGPT, Claude, and comparable tools; the formulation of effective prompts; the iteration between AI generation and human review; the recognition of AI strengths (boilerplate, well-known patterns, syntax) vs. weaknesses (nuanced engineering context, novel problems, subtle correctness).
• AI-Assisted Debugging: Using AI tools to explain unfamiliar code; debug error messages; suggest fixes; identify likely sources of bugs; the limits of AI debugging.
• AI-Assisted Engineering Analysis: Using AI to support problem formulation; methodology selection; result interpretation; the boundary between AI as analysis support and AI as decision-maker (the engineer remains the decision-maker).
• Responsible AI Integration: Verification of AI-generated code (correctness, appropriateness, security); recognition of AI failure modes (hallucinated APIs, subtle logic errors, outdated patterns); the maintenance of engineering judgment as primary; the engineer's continuing professional accountability for AI-assisted output; ethical considerations (attribution, intellectual property, the appropriate disclosure of AI assistance).
• Reading and Evaluating AI-Generated Code: The professional engineer must be able to read and understand the code they sign off on; the discipline of code review applied to AI-generated code; the development of pattern-recognition for AI failure modes.

Optional Topics

• Deep Learning: PyTorch or TensorFlow at introductory level; common architectures (feedforward, convolutional); engineering applications.
• Web-Based Engineering Tools: Flask for simple web applications; Streamlit for engineering dashboards; the deployment of engineering tools as web applications.
• Cloud Computing: AWS, Azure, or GCP at introductory level for engineering computation; cloud-based data storage; cloud-based ML platforms.
• Performance and Parallelism: NumPy vectorization for performance; multiprocessing for parallel computation; profiling and optimization at introductory level.
• API Development: The creation of REST APIs for engineering tools (with Flask or FastAPI); the integration of engineering tools across systems.

Resources & Tools

• Common Texts: Python for Data Analysis (McKinney — pandas creator); Python Crash Course (Matthes — popular introductory text); Python Programming and Numerical Methods: A Guide for Engineers and Scientists (Kong/Siauw/Bayen — free online); Effective Computation in Physics (Scopatz/Huff — engineering-flavored); Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (Géron) for the ML content
• Open Educational Resources: Python Programming and Numerical Methods (free, online textbook, engineering-focused); Real Python tutorials (free); the official Python documentation; SciPy lecture notes; Jake VanderPlas's Python Data Science Handbook (free online)
• AI Tools: GitHub Copilot (paid, but with student access); ChatGPT (free tier and paid); Claude.ai (free tier and paid); these tools are foundational to the course's modern programming workflow
• Software: Python 3.x (free, open source); IDE choices (VS Code with Python extension, PyCharm Community, Spyder, Jupyter); package management (pip, conda); virtual environments (venv, conda environments); Git and GitHub
• Reference Resources: Stack Overflow (for community programming help); Python documentation (docs.python.org); NumPy documentation; pandas documentation; scikit-learn documentation; scipy documentation; matplotlib gallery for visualization examples

Career Pathways

Programming proficiency in Python is increasingly central to engineering careers across disciplines:

• All Engineering Disciplines — Python has become the dominant scientific programming language in engineering; competency supports careers across mechanical, civil, aerospace, biomedical, electrical, chemical, and industrial engineering.
• Engineering Data Analysis Roles — Direct preparation for data-intensive engineering roles.
• R&D Engineering — Research and development roles increasingly require Python programming.
• Engineering Software Development — Engineers developing engineering software tools.
• Engineering Automation Roles — Roles automating engineering workflows and integrating engineering tools.
• Machine Learning and Engineering Data Science — The bridge from engineering programming to ML/data science careers.
• Graduate Engineering Study — Foundation for graduate work where Python is the dominant analytical tool.
• The AI-Assisted Engineering Workforce — Engineers who effectively integrate AI tools into their work have substantial career advantages in the contemporary engineering workplace.

Special Information

The Two-Phase Course Structure

EGN3214's structure intentionally addresses a recognized gap in engineering programming education. First-year engineering programming courses (in EGN1001C/1002C/1007C) typically establish basic programming literacy; senior-level courses assume programming proficiency; but many engineering students arrive at upper-division work with insufficient programming depth for real engineering use. EGN3214 explicitly bridges this gap — establishing solid Python foundations in Phase 1, then applying them substantively to engineering problems in Phase 2.

The AI-Integrated Approach

EGN3214's substantial integration of AI-assisted coding tools reflects a deliberate pedagogical choice grounded in current engineering practice. AI-assisted programming is increasingly the dominant programming workflow in industry; engineering education that ignores AI tools risks preparing students for a workplace that no longer exists. The course addresses both the use of AI tools (effective prompting, iteration with AI assistants) and the responsible integration of AI tools (verification, professional judgment, the engineer's continuing accountability).

The course explicitly emphasizes that AI integration does not reduce the engineer's responsibility to understand the work. Engineers who blindly trust AI-generated code, who cannot read and evaluate that code, who cannot recognize when AI suggestions are wrong — these engineers are professionally vulnerable. The course's goal is to develop graduates who are both effective with AI tools and intellectually independent of them.

Single-Institution Course

EGN3214 is offered at a single Florida institution. Students at other Florida institutions interested in similar content should consult comparable courses at their institution (which may include first-year engineering programming, EGN2210C — Engineering Analysis and Computation, or other discipline-specific programming courses). Students transferring credit for EGN3214 should consult the receiving institution about specific application.

Course Format

EGN3214 is offered in face-to-face, hybrid, and increasingly online formats. The programming-intensive nature of the course translates well to online delivery; many institutions offer fully asynchronous online sections.

Position in the Engineering Curriculum

EGN3214 is typically taken in the third year of engineering study, after the first-year programming exposure and after foundational mathematics. The course supports subsequent engineering coursework requiring substantive programming (capstone design, senior elective courses with computational content, research projects) and prepares students for industry roles requiring Python proficiency.

Continuing Development

The Python ecosystem and the AI tools landscape both evolve rapidly. Students completing EGN3214 should expect to continue developing their programming skills throughout their careers — the foundational concepts (Python language fundamentals, scientific computing patterns, the integration with engineering analysis) remain stable while the specific tools, libraries, and AI capabilities will continue to develop. The course establishes the foundation; lifelong learning maintains the edge.