Contextual Computing for Engineers

Computing skills are vital not just for computer scientists but for people of all disciplines ranging from art to zoology. It assumes even greater prominence in more quantitative fields such as physical sciences and engineering. For example, the Nobel Prize in Physics this year (2021) was awarded to three researchers for understanding complex systems using chaos theory across a wide range of scales (atomic to planetary) and understanding climate change. This work would not have been possible without computers and as an interesting factoid, one of the winners’ Syukuro Manabe used a computer with 0.5 MB RAM (yes one-half megabytes) to create a climate model that proved some early findings by stalwarts like Arrhenius and Fourier.

One can look through the glowing roster of Nobel Laureate’s in many disciplines to see the vital role computers have played in advancing their science. Another thing to note is also that most of these winners were not classically trained as computer scientists and their training in computer programming was limited to a few classes at best and none many times. While Nobel Laureate’s provide a visible example, a great number of working engineers and scientists routinely write code to automate boring tasks, get more precise calculations, visualize and present their results and finding.

 Computing is at the very core of all engineering endeavors.  Naturally, undergraduate engineering curricula across the world have at least one programming course in them. 

Questions such as – 1) What is the best way to teach introductory programming courses to engineers? and 2) Who should be teaching these classes (classically trained computer scientists or computationally-oriented engineers?) come to fore.

Given their discipline-specific training, one would argue that computer scientists are best suited to teach these courses. While this argument indeed passes the academic rigor test, does this academic expertise necessarily translate into teaching the programming skills that engineers need?

Computer science tends to be application agnostic. After all, many algorithms such as sorting, nearest neighbor search and others can be applied in a wide range of applications. Thus, computer scientists are classically trained learn the workings of the algorithm more so than their application to a specific problem.

Engineering students on the other hand view programming as another skill-set that is needed to achieve their goal. A student might want to become a civil engineer and build skyscrapers, to her, computational analysis is a means to achieve that goal. It is likely that as a first year student, she may not come into the introductory programming class with an understanding of how computational analysis may be even useful to fulfill her dream of building skyscrapers. An abstract presentation of programming methods, therefore may leave this student dissatisfied and provides no bridge to make connections to their chosen field of study.

Contextual computing is the idea of teaching computer programming in context. Programming concepts and algorithms are put in context of an application (say solving an engineering analysis or design problem). This approach is clearly not the way to teach introductory programming classes to computer science majors who need to focus on the algorithm more so than an application. Contextual programming may actually preclude computer science majors from seeing the algorithm and techniques in an abstract form. On the other hand, contextual computing is perhaps the best way to teach programming to engineers. As students take introductory programming courses before courses in their chosen discipline. This approach not only leads to better engagement but also tells them that programming is an important skill-set to have for pursuing their dreams. This makes them focus on programming courses more than they would if it were to be presented in an abstract form.

I incorporate elements of programming and computing in all my classes (both undergraduate and graduate level). Students often tell me that they should have paid more attention to learning programming but did not feel it was necessary as it did not seem connected to what they wanted to study. This course was a box they wanted to check and move on to real exciting stuff. A contextual computing course would likely made them pay more attention and learn programming better.

If one were to accept that contextual computing approach to teach introductory programming is better suited for engineers and certainly preferred over abstract presentations. The next logical questions is who should be teaching introductory programming to engineers? On one hand, computer scientists lack application knowledge and engineers are not rigorously trained as computer scientists.

Ideally, a collaboration between an application-minded computer scientist and a computationally-oriented engineer would make a perfect team to teach such a course. They could complement each other to create exciting content. However, creating such teams in siloed university settings is often difficult. This means either computer scientists have to make an effort to learn enough engineering to excite first year engineering students in their class or engineers must know enough computer science and draw context to help engineers understand the value of computer science.

From a strictly practical viewpoint, I think an engineering with sufficient programming skills is better suited to teach introductory programming courses to engineers than a computer scientist foraying into the application domain and contextualizing programming lectures.

My reasoning for this is simple, we have great many examples of people who have learned programming either informally or semi-formally (think Bill Gates, Steve Jobs) and carved out successful careers using programming. Many students from a variety of STEM disciplines get into programming jobs every year.

However, it is next to impossible for a non-engineer to work in an engineering field. In most instances you are explicitly prohibited by law to do so!! Resources to learn programming are plenty in both formal and informal settings (You Tube, Coursera, a plethora of books and other resources). In addition, computationally-oriented engineers have not only had formal training in programming intensive computational courses but constantly use them in engineering applications and research. So they have both the background and access to resources to continue to learn programming. On the other hand, engineering resources are not as easy to find to help Computer Scientists contextualize their teaching.

The learning curve for a Computer Scientist to contextualize programming is definitely steeper than for a computationally-oriented engineer to keep up-to-date with programming principles and concepts.

Therefore, it might be best for engineers to be teaching introductory programming courses to engineering students. I am not advocating that computer scientists be completely removed from the process. For example, Computer Science faculty can help computationally-oriented engineers stay current on programming trends by conducting workshops and introducing them to newer ideas and programming methods. They can serve as peer-reviewers and add academic rigor. They can play a key role in enhancing undergraduate engineering programming by working with engineers to integrate cloud computing. They can provide resources to students interested in learning more. I think such steps will help towards a more transformative teaching paradigm that results from fruitful collaborations between computer science and engineering faculty and benefit the students in the long run. Universities must strive to create opportunities and rewards to foster such collaborations, value and reward out-of-the-box teaching paradigms.