DOCSLIB.ORG

Teaching Python Programming to Novices: Addressing Misconceptions and Creating a Development Environment

Total Page：16

File Type：pdf, Size：1020Kb

Download full-text PDF Read full-text
Teaching Python Programming to Novices: Addressing Misconceptions and Creating a Development Environment Research Collection Doctoral Thesis Teaching Python Programming to Novices: Addressing Misconceptions and Creating a Development Environment Author(s): Kohn, Tobias Publication Date: 2017 Permanent Link: https://doi.org/10.3929/ethz-a-010871088 Rights / License: In Copyright - Non-Commercial Use Permitted This page was generated automatically upon download from the ETH Zurich Research Collection. For more information please consult the Terms of use. ETH Library DISS. ETH NO. 24076 Teaching Python Programming to Novices: Addressing Misconceptions and Creating a Development Environment A thesis submitted to attain the degree of DOCTOR OF SCIENCES of ETH ZURICH (Dr. sc. ETH Zurich) presented by Tobias Kohn Dipl. Math, ETH Zurich born on January 31, 1982 citizen of Endingen (AG) accepted on the recommendation of Prof. Dr. Juraj Hromkoviˇc, examiner Prof. Dr. Bill Manaris, co-examiner Prof. Dr. Thomas R. Gross, co-examiner Prof. Dr. Jürg Gutknecht, co-examiner 2017 Für Sarah Abstract One of the great challenges in teaching to program is to help students understand how pro- gramming actually works. Students unavoidably develop misconceptions during their learning process, which must be corrected through skillful feedback. Such misconceptions reach from rather simple syntactical problems to deep underlying misunderstandings about what a compu- tational machine is, and how it works. With the objective to assist the students in developing correct mental models, we must understand these misconceptions, and how to correct them. An example of a misconception about the syntax is the well-documented problem that the assignment operator is believed to be symmetric, i. e., 2 = x is seen as equivalent to x = 2. At the other end of the spectrum, we find fundamental misconceptions about the computational machine itself. One such misconception is to apply a model of mathematical procedure to the computational machine, and thereby attribute algebraic capabilities to the machine. This is evidenced by the belief that the statement y = 2*x establishes a link between the two variables x and y, so that any change of x is subsequently also reflected by y. The primary and foremost means to detect misconceptions is through careful analysis of the students’ mistakes and errors. While some errors lead to syntactically incorrect programs, which are not even accepted by the computer, and therefore quickly recognized, other errors show themselved in incorrect outputs once the program is run. However, the main question to answer is: what can we infer about a student’s mental models and misconceptions from his or her errors? This dissertation investigates the errors of novice programming students in high school. In particular, it provides evidence that some students apply a model of mathematical substitution when reasoning about variables in a program. This misconception is relevant as it directly per- tains the sequential nature and data abstraction as employed in imperative computer program- ming; in fact, variables are a core concept in imperative programming. However, the dissertation also proposes a teaching method to specifically overcome this misconception by carefully ad- dressing it in the classroom. Preliminary results are promising, and indicate that such dedicated teaching might indeed be effective. During a period of five years, we have collected erroneous program of novice programming high school students. Based on this collection, the dissertation includes a list of common stu- dent errors. While there are several such collections of student errors already available, this PhD-Thesis, Tobias Kohn, 2017 vi dissertation provides the first collection based on the programming language Python. Python has recently become a popular programming language for introductory courses. At the same time, it differs significantly from more traditional programming languages such as Java, in both syntax and execution model. Hence, many previously documented errors do not apply equally to Python. Finally, the dissertation describes a parser for Python programs, capable of recognizing var- ious error patterns, as documented in the collection of student errors. The parser has been implemented as part of the educational Python environment “TigerJython”, which has already found widespread use. Moreover, with the possibility to discern different errors more accurately than what traditional Python environments provide, future research can study the relationships between the observed errors and the underlying misconception of students in more detail. PhD-Thesis, Tobias Kohn, 2017 Zusammenfassung Eine der grossen Herausforderungen im Programmierunterricht besteht darin, in den Lernen- den das Verständnis zu fördern, wie Programmieren tatsächlich funktioniert. Während ihres Lernprozesses machen Schüler und Studenten unweigerlich Fehler und entwickeln Fehlvorstel- lungen, die durch gezielte Rückmeldungen korrigiert werden müssen. Diese Fehlvorstellungen reichen von einfachen syntaktischen Problemen bis hin zu einem tief liegenden Misverständnis darüber, was eine Rechenmaschine eigentlich ist und wie sie funktioniert. Mit dem Ziel, die Ler- nenden bei der Entwicklung korrekter mentaler Modelle zu unterstützen müssen wie ihre Fehler und Fehlvorstellungen untersuchen und studieren, wie sie korrigiert werden können. Ein bekanntes Beispiel für eine syntaktische Fehlvorstellung liegt im Glauben, der Zuweisung- soperator sei symmetrisch. Die beiden Varianten x = 2 und 2 = x werden also als äquivalent angesehen. Auf der anderen Seite des Spektrums finden wir grundlegende Fehlvorstellungen über die Rechenmaschine selbst. Zum Beispiel tendieren einige Lernende dazu, ihr mathema- tisches Vorwissen auf die Rechenmaschine zu übertragen und gehen dann davon aus, dass die Maschine algebraische Fähigkeiten besitzt. Die Anweisung y = 2*x wird dann so verstanden, dass sie die beiden Variablen x und y fest miteinander verknüpft. Wenn wir später also den Wert von x ändern, dann würde diese Änderung auch sofort im Wert von y sichtbar. Das wichtigste Mittel, um Fehlvorstellungen zu erkennen und zu untersuchen, ist eine sorgfältige Analyse der Fehler, die Schüler und Studenten machen. Während einige Fehler zu syntaktisch falschen Programmen führen, die schon vom Computer abgelehnt werden und daher einfach zu erkennen sind, äussern sich andere Fehler erst in den falschen Ausgaben, wenn das Programm ausgeführt wird. Die Hauptfrage ist aber in jedem Fall: Was für Schlüsse können wir aus den beobachteten Fehlern ziehen, um die mentalen Modelle und Fehlvorstellungen der Lernenden zu verstehen? Die vorliegende Dissertation untersucht die Fehler von Schülerinnen und Schülern im Gym- nasium, die einen Anfängerkurs in der Programmierung besuchen. Dabei präsentieren wir vor allem auch Indizien dafür, dass einige der Schüler ein Modell der mathematischen Substitution auf das Programmieren anwenden, wenn es darum geht, das Verhalten von Variablen im Pro- gramm zu erklären. Das ist insofern relevant, weil Variablen ein Kernkonzept der imperativen Programmierung darstellen. Tatsächlich hängen die Fehlvorstellungen der Schüler direkt mit PhD-Thesis, Tobias Kohn, 2017 viii der sequentiellen Natur und der Datenabstraktion zusammen, zwei essentiellen Begriffen für die Programmierung. Die Dissertation stellt aber auch einen Ansatz vor, um diese Fehlvorstellungen in der Klasse zu korrigieren, indem das Problem bewusst und gezielt angegangen wird. Erste Ergebnisse dazu sind vielversprechend. Während fünf Jahren haben wir eine Sammlung an fehlerhaften Programmen von Gym- nasialschülern angelegt. Basierend auf dieser Sammlung enthält die Dissertation auch eine Liste mit häufigeren Fehlern. Natürlich gibt es bereits einige solche Listen und Zusammenstellun- gen, allerdings präsentieren wir die erste Liste zur Programmiersprache Python. Python erfreut sich zur Zeit wachsender Beliebtheit als Anfängersprache. Gleichzeitig unterscheidet sich Python aber auch relativ stark von traditionelleren Sprachen wie Java, und zwar sowohl in der Syntax als auch im Ausführungsmodell. Entsprechend lassen sich viele frühere Ergebnisse nicht einfach übertragen. Schliesslich stellt diese Dissertation auch einen Parser für Python vor, der eine ganze Reihe von Fehlern erkennt, die zuvor dokumentiert wurden. Dieser Parser ist bereits Teil der Python- Umgebung “TigerJython” für den Unterricht, die relativ weit verbreitet ist und vielfältig einge- setzt wird. Darüber hinaus ermöglicht die systematische Erkennung von Fehlern aber ach zukün- ftige Forschung, insbesondere das Studium der Beziehungen zwischen den beobachteten Fehlern und den tatsächlich zugrunde liegenden Fehlvorstellungen. PhD-Thesis, Tobias Kohn, 2017 Acknowledgments Apart from the scientific results, the writing of this dissertation has brought me in contact with many great people. I feel a deep gratitude for all the opportunities, the support, and the friend- ship I have received during this time, and I would like to express my highest appreciation. In particular, I would like to thank the following people. When I first approached Profs. Juraj Hromkoviˇc and Jürg Gutknecht with my ideas for this dissertation, I quickly found their full endorsement. I am most grateful for their extensive sup- port, their trust and skillful advice. Both allowed me to always pursue my own ideas, and learn from my own mistakes, while still guiding and assisting me when necessary. In addition, Prof. Thomas R. Gross has supported and guided me in my studies of parsing technologies. Moreover, he provided
Load more

Recommended publications
  • A Call-By-Need Lambda Calculus
    A CallByNeed Lamb da Calculus Zena M Ariola Matthias Fel leisen Computer Information Science Department Department of Computer Science University of Oregon Rice University Eugene Oregon Houston Texas John Maraist and Martin Odersky Philip Wad ler Institut fur Programmstrukturen Department of Computing Science Universitat Karlsruhe UniversityofGlasgow Karlsruhe Germany Glasgow Scotland Abstract arguments value when it is rst evaluated More pre cisely lazy languages only reduce an argument if the The mismatchbetween the op erational semantics of the value of the corresp onding formal parameter is needed lamb da calculus and the actual b ehavior of implemen for the evaluation of the pro cedure b o dy Moreover af tations is a ma jor obstacle for compiler writers They ter reducing the argument the evaluator will remember cannot explain the b ehavior of their evaluator in terms the resulting value for future references to that formal of source level syntax and they cannot easily com parameter This technique of evaluating pro cedure pa pare distinct implementations of dierent lazy strate rameters is called cal lbyneed or lazy evaluation gies In this pap er we derive an equational characteri A simple observation justies callbyneed the re zation of callbyneed and prove it correct with resp ect sult of reducing an expression if any is indistinguish to the original lamb da calculus The theory is a strictly able from the expression itself in all p ossible contexts smaller theory than the lamb da calculus Immediate Some implementations attempt
    [Show full text]
  • Towards a Fully Automated Extraction and Interpretation of Tabular Data Using Machine Learning
    UPTEC F 19050 Examensarbete 30 hp August 2019 Towards a fully automated extraction and interpretation of tabular data using machine learning Per Hedbrant Per Hedbrant Master Thesis in Engineering Physics Department of Engineering Sciences Uppsala University Sweden Abstract Towards a fully automated extraction and interpretation of tabular data using machine learning Per Hedbrant Teknisk- naturvetenskaplig fakultet UTH-enheten Motivation A challenge for researchers at CBCS is the ability to efficiently manage the Besöksadress: different data formats that frequently are changed. Significant amount of time is Ångströmlaboratoriet Lägerhyddsvägen 1 spent on manual pre-processing, converting from one format to another. There are Hus 4, Plan 0 currently no solutions that uses pattern recognition to locate and automatically recognise data structures in a spreadsheet. Postadress: Box 536 751 21 Uppsala Problem Definition The desired solution is to build a self-learning Software as-a-Service (SaaS) for Telefon: automated recognition and loading of data stored in arbitrary formats. The aim of 018 – 471 30 03 this study is three-folded: A) Investigate if unsupervised machine learning Telefax: methods can be used to label different types of cells in spreadsheets. B) 018 – 471 30 00 Investigate if a hypothesis-generating algorithm can be used to label different types of cells in spreadsheets. C) Advise on choices of architecture and Hemsida: technologies for the SaaS solution. http://www.teknat.uu.se/student Method A pre-processing framework is built that can read and pre-process any type of spreadsheet into a feature matrix. Different datasets are read and clustered. An investigation on the usefulness of reducing the dimensionality is also done.
    [Show full text]
  • NU-Prolog Reference Manual
    NU-Prolog Reference Manual Version 1.5.24 edited by James A. Thom & Justin Zobel Technical Report 86/10 Machine Intelligence Project Department of Computer Science University of Melbourne (Revised November 1990) Copyright 1986, 1987, 1988, Machine Intelligence Project, The University of Melbourne. All rights reserved. The Technical Report edition of this publication is given away free subject to the condition that it shall not, by the way of trade or otherwise, be lent, resold, hired out, or otherwise circulated, without the prior consent of the Machine Intelligence Project at the University of Melbourne, in any form or cover other than that in which it is published and without a similar condition including this condition being imposed on the subsequent user. The Machine Intelligence Project makes no representations or warranties with respect to the contents of this document and specifically disclaims any implied warranties of merchantability or fitness for any particular purpose. Furthermore, the Machine Intelligence Project reserves the right to revise this document and to make changes from time to time in its content without being obligated to notify any person or body of such revisions or changes. The usual codicil that no part of this publication may be reproduced, stored in a retrieval system, used for wrapping fish, or transmitted, in any form or by any means, electronic, mechanical, photocopying, paper dart, recording, or otherwise, without someone's express permission, is not imposed. Enquiries relating to the acquisition of NU-Prolog should be made to NU-Prolog Distribution Manager Machine Intelligence Project Department of Computer Science The University of Melbourne Parkville, Victoria 3052 Australia Telephone: (03) 344 5229.
    [Show full text]
  • Variable-Arity Generic Interfaces
    Variable-Arity Generic Interfaces T. Stephen Strickland, Richard Cobbe, and Matthias Felleisen College of Computer and Information Science Northeastern University Boston, MA 02115 [email protected] Abstract. Many programming languages provide variable-arity func- tions. Such functions consume a fixed number of required arguments plus an unspecified number of \rest arguments." The C++ standardiza- tion committee has recently lifted this flexibility from terms to types with the adoption of a proposal for variable-arity templates. In this paper we propose an extension of Java with variable-arity interfaces. We present some programming examples that can benefit from variable-arity generic interfaces in Java; a type-safe model of such a language; and a reduction to the core language. 1 Introduction In April of 2007 the C++ standardization committee adopted Gregor and J¨arvi's proposal [1] for variable-length type arguments in class templates, which pre- sented the idea and its implementation but did not include a formal model or soundness proof. As a result, the relevant constructs will appear in the upcom- ing C++09 draft. Demand for this feature is not limited to C++, however. David Hall submitted a request for variable-arity type parameters for classes to Sun in 2005 [2]. For an illustration of the idea, consider the remarks on first-class functions in Scala [3] from the language's homepage. There it says that \every function is a value. Scala provides a lightweight syntax for defining anonymous functions, it supports higher-order functions, it allows functions to be nested, and supports currying." To achieve this integration of objects and closures, Scala's standard library pre-defines ten interfaces (traits) for function types, which we show here in Java-like syntax: interface Function0<Result> { Result apply(); } interface Function1<Arg1,Result> { Result apply(Arg1 a1); } interface Function2<Arg1,Arg2,Result> { Result apply(Arg1 a1, Arg2 a2); } ..
    [Show full text]
  • Advanced Data Mining with Weka (Class 5)
    Advanced Data Mining with Weka Class 5 – Lesson 1 Invoking Python from Weka Peter Reutemann Department of Computer Science University of Waikato New Zealand weka.waikato.ac.nz Lesson 5.1: Invoking Python from Weka Class 1 Time series forecasting Lesson 5.1 Invoking Python from Weka Class 2 Data stream mining Lesson 5.2 Building models in Weka and MOA Lesson 5.3 Visualization Class 3 Interfacing to R and other data mining packages Lesson 5.4 Invoking Weka from Python Class 4 Distributed processing with Apache Spark Lesson 5.5 A challenge, and some Groovy Class 5 Scripting Weka in Python Lesson 5.6 Course summary Lesson 5.1: Invoking Python from Weka Scripting Pros script captures preprocessing, modeling, evaluation, etc. write script once, run multiple times easy to create variants to test theories no compilation involved like with Java Cons programming involved need to familiarize yourself with APIs of libraries writing code is slower than clicking in the GUI Invoking Python from Weka Scripting languages Jython - https://docs.python.org/2/tutorial/ - pure-Java implementation of Python 2.7 - runs in JVM - access to all Java libraries on CLASSPATH - only pure-Python libraries can be used Python - invoking Weka from Python 2.7 - access to full Python library ecosystem Groovy (briefly) - http://www.groovy-lang.org/documentation.html - Java-like syntax - runs in JVM - access to all Java libraries on CLASSPATH Invoking Python from Weka Java vs Python Java Output public class Blah { 1: Hello WekaMOOC! public static void main(String[]
    [Show full text]
  • Introduction to Weka
    Introduction to Weka Overview What is Weka? Where to find Weka? Command Line Vs GUI Datasets in Weka ARFF Files Classifiers in Weka Filters What is Weka? Weka is a collection of machine learning algorithms for data mining tasks. The algorithms can either be applied directly to a dataset or called from your own Java code. Weka contains tools for data pre-processing, classification, regression, clustering, association rules, and visualization. It is also well-suited for developing new machine learning schemes. Where to find Weka Weka website (Latest version 3.6): – http://www.cs.waikato.ac.nz/ml/weka/ Weka Manual: − http://transact.dl.sourceforge.net/sourcefor ge/weka/WekaManual-3.6.0.pdf CLI Vs GUI Recommended for in-depth usage Explorer Offers some functionality not Experimenter available via the GUI Knowledge Flow Datasets in Weka Each entry in a dataset is an instance of the java class: − weka.core.Instance Each instance consists of a number of attributes Attributes Nominal: one of a predefined list of values − e.g. red, green, blue Numeric: A real or integer number String: Enclosed in “double quotes” Date Relational ARFF Files The external representation of an Instances class Consists of: − A header: Describes the attribute types − Data section: Comma separated list of data ARFF File Example Dataset name Comment Attributes Target / Class variable Data Values Assignment ARFF Files Credit-g Heart-c Hepatitis Vowel Zoo http://www.cs.auckland.ac.nz/~pat/weka/ ARFF Files Basic statistics and validation by running: − java weka.core.Instances data/soybean.arff Classifiers in Weka Learning algorithms in Weka are derived from the abstract class: − weka.classifiers.Classifier Simple classifier: ZeroR − Just determines the most common class − Or the median (in the case of numeric values) − Tests how well the class can be predicted without considering other attributes − Can be used as a Lower Bound on Performance.
    [Show full text]
  • Small Hitting-Sets for Tiny Arithmetic Circuits Or: How to Turn Bad Designs Into Good
    Electronic Colloquium on Computational Complexity, Report No. 35 (2017) Small hitting-sets for tiny arithmetic circuits or: How to turn bad designs into good Manindra Agrawal ∗ Michael Forbes† Sumanta Ghosh ‡ Nitin Saxena § Abstract Research in the last decade has shown that to prove lower bounds or to derandomize polynomial identity testing (PIT) for general arithmetic circuits it suffices to solve these questions for restricted circuits. In this work, we study the smallest possibly restricted class of circuits, in particular depth-4 circuits, which would yield such results for general circuits (that is, the complexity class VP). We show that if we can design poly(s)-time hitting-sets for Σ ∧a ΣΠO(log s) circuits of size s, where a = ω(1) is arbitrarily small and the number of variables, or arity n, is O(log s), then we can derandomize blackbox PIT for general circuits in quasipolynomial time. Further, this establishes that either E6⊆#P/poly or that VP6=VNP. We call the former model tiny diagonal depth-4. Note that these are merely polynomials with arity O(log s) and degree ω(log s). In fact, we show that one only needs a poly(s)-time hitting-set against individual-degree a′ = ω(1) polynomials that are computable by a size-s arity-(log s) ΣΠΣ circuit (note: Π fanin may be s). Alternatively, we claim that, to understand VP one only needs to find hitting-sets, for depth-3, that have a small parameterized complexity. Another tiny family of interest is when we restrict the arity n = ω(1) to be arbitrarily small.
    [Show full text]
  • Making a Faster Curry with Extensional Types
    Making a Faster Curry with Extensional Types Paul Downen Simon Peyton Jones Zachary Sullivan Microsoft Research Zena M. Ariola Cambridge, UK University of Oregon [email protected] Eugene, Oregon, USA [email protected] [email protected] [email protected] Abstract 1 Introduction Curried functions apparently take one argument at a time, Consider these two function definitions: which is slow. So optimizing compilers for higher-order lan- guages invariably have some mechanism for working around f1 = λx: let z = h x x in λy:e y z currying by passing several arguments at once, as many as f = λx:λy: let z = h x x in e y z the function can handle, which is known as its arity. But 2 such mechanisms are often ad-hoc, and do not work at all in higher-order functions. We show how extensional, call- It is highly desirable for an optimizing compiler to η ex- by-name functions have the correct behavior for directly pand f1 into f2. The function f1 takes only a single argu- expressing the arity of curried functions. And these exten- ment before returning a heap-allocated function closure; sional functions can stand side-by-side with functions native then that closure must subsequently be called by passing the to practical programming languages, which do not use call- second argument. In contrast, f2 can take both arguments by-name evaluation. Integrating call-by-name with other at once, without constructing an intermediate closure, and evaluation strategies in the same intermediate language ex- this can make a huge difference to run-time performance in presses the arity of a function in its type and gives a princi- practice [Marlow and Peyton Jones 2004].
    [Show full text]
  • Mathematica Document
    Mathematica Project: Exploratory Data Analysis on ‘Data Scientists’ A big picture view of the state of data scientists and machine learning engineers. ����� ���� ��������� ��� ������ ���� ������ ������ ���� ������/ ������ � ���������� ���� ��� ������ ��� ���������������� �������� ������/ ����� ��������� ��� ���� ���������������� ����� ��������������� ��������� � ������(�������� ���������� ���������) ������ ��������� ����� ������� �������� ����� ������� ��� ������ ����������(���� �������) ��������� ����� ���� ������ ����� (���������� �������) ����������(���������� ������� ���������� ��� ���� ���� �����/ ��� �������������� � ����� ���� �� �������� � ��� ����/���������� ��������������� ������� ������������� ��� ���������� ����� �����(���� �������) ����������� ����� / ����� ��� ������ ��������������� ���������� ����������/�++ ������/������������/����/������ ���� ������� ����� ������� ������� ����������������� ������� ������� ����/����/�������/��/��� ����������(�����/����-�������� ��������) ������������ In this Mathematica project, we will explore the capabilities of Mathematica to better understand the state of data science enthusiasts. The dataset consisting of more than 10,000 rows is obtained from Kaggle, which is a result of ‘Kaggle Survey 2017’. We will explore various capabilities of Mathematica in Data Analysis and Data Visualizations. Further, we will utilize Machine Learning techniques to train models and Classify features with several algorithms, such as Nearest Neighbors, Random Forest. Dataset : https : // www.kaggle.com/kaggle/kaggle
    [Show full text]
  • WEKA: the Waikato Environment for Knowledge Analysis
    WEKA: The Waikato Environment for Knowledge Analysis Stephen R. Garner Department of Computer Science, University of Waikato, Hamilton. ABSTRACT WEKA is a workbench designed to aid in the application of machine learning technology to real world data sets, in particular, data sets from New Zealand’s agricultural sector. In order to do this a range of machine learning techniques are presented to the user in such a way as to hide the idiosyncrasies of input and output formats, as well as allow an exploratory approach in applying the technology. The system presented is a component based one that also has application in machine learning research and education. 1. Introduction The WEKA machine learning workbench has grown out of the need to be able to apply machine learning to real world data sets in a way that promotes a “what if?…” or exploratory approach. Each machine learning algorithm implementation requires the data to be present in its own format, and has its own way of specifying parameters and output. The WEKA system was designed to bring a range of machine learning techniques or schemes under a common interface so that they may be easily applied to this data in a consistent method. This interface should be flexible enough to encourage the addition of new schemes, and simple enough that users need only concern themselves with the selection of features in the data for analysis and what the output means, rather than how to use a machine learning scheme. The WEKA system has been used over the past year to work with a variety of agricultural data sets in order to try to answer a range of questions.
    [Show full text]
  • Artificial Intelligence for the Prediction of Exhaust Back Pressure Effect On
    applied sciences Article Artificial Intelligence for the Prediction of Exhaust Back Pressure Effect on the Performance of Diesel Engines Vlad Fernoaga 1 , Venetia Sandu 2,* and Titus Balan 1 1 Faculty of Electrical Engineering and Computer Science, Transilvania University, Brasov 500036, Romania; [email protected] (V.F.); [email protected] (T.B.) 2 Faculty of Mechanical Engineering, Transilvania University, Brasov 500036, Romania * Correspondence: [email protected]; Tel.: +40-268-474761 Received: 11 September 2020; Accepted: 15 October 2020; Published: 21 October 2020 Featured Application: This paper presents solutions for smart devices with embedded artificial intelligence dedicated to vehicular applications. Virtual sensors based on neural networks or regressors provide real-time predictions on diesel engine power loss caused by increased exhaust back pressure. Abstract: The actual trade-off among engine emissions and performance requires detailed investigations into exhaust system configurations. Correlations among engine data acquired by sensors are susceptible to artificial intelligence (AI)-driven performance assessment. The influence of exhaust back pressure (EBP) on engine performance, mainly on effective power, was investigated on a turbocharged diesel engine tested on an instrumented dynamometric test-bench. The EBP was externally applied at steady state operation modes defined by speed and load. A complete dataset was collected to supply the statistical analysis and machine learning phases—the training and testing of all the AI solutions developed in order to predict the effective power. By extending the cloud-/edge-computing model with the cloud AI/edge AI paradigm, comprehensive research was conducted on the algorithms and software frameworks most suited to vehicular smart devices.
    [Show full text]
  • Statistical Software
    Statistical Software A. Grant Schissler1;2;∗ Hung Nguyen1;3 Tin Nguyen1;3 Juli Petereit1;4 Vincent Gardeux5 Keywords: statistical software, open source, Big Data, visualization, parallel computing, machine learning, Bayesian modeling Abstract Abstract: This article discusses selected statistical software, aiming to help readers find the right tool for their needs. We categorize software into three classes: Statisti- cal Packages, Analysis Packages with Statistical Libraries, and General Programming Languages with Statistical Libraries. Statistical and analysis packages often provide interactive, easy-to-use workflows while general programming languages are built for speed and optimization. We emphasize each software's defining characteristics and discuss trends in popularity. The concluding sections muse on the future of statistical software including the impact of Big Data and the advantages of open-source languages. This article discusses selected statistical software, aiming to help readers find the right tool for their needs (not provide an exhaustive list). Also, we acknowledge our experiences bias the discussion towards software employed in scholarly work. Throughout, we emphasize the software's capacity to analyze large, complex data sets (\Big Data"). The concluding sections muse on the future of statistical software. To aid in the discussion, we classify software into three groups: (1) Statistical Packages, (2) Analysis Packages with Statistical Libraries, and (3) General Programming Languages with Statistical Libraries. This structure
    [Show full text]