Content uploaded by Jose Manuel Redondo
Author content
All content in this area was uploaded by Jose Manuel Redondo on Jan 03, 2022
Content may be subject to copyright.
A preview of the PDF is not available
C# a través del Fanzine: Entendiendo Conceptos de C# de Forma Sencilla (Edición en Español)
Abstract
Esta es la culminación del trabajo desarrollado en base a un proyecto docente y del artículo de investigación publicado en el ICSE 2021 sobre el uso de zines para la enseñanza de programación, usando C# como lenguaje vehícular. An English version is also available in my ResearchGate profile.
ResearchGate has not been able to resolve any citations for this publication.
This is the ongoing work of a teaching innovation project I manage, to reinforce learning of hacking-related concepts for undergraduate students with zero or very limited previous experience.
This is the pilot prototype of a second series of zines dedicated to teaching infrastructure administration concepts. This is a Work In Progress and Content is expected to be updated regularly.
This article is available (in Spanish) at: https://www.compartimoss.com/revistas/numero-46/ahorrando-codigo-funcionalidades-de-c-para-no-programar-de-mas
Specialized digital fanzines were successfully used to facilitate learning problematic concepts in an undergraduate programming course, dynamically adapting to student needs. The design of these fanzines favors creating and reading them quickly by establishing a common graphical layout, rules, and focusing in the most problematic parts of the concepts. This paper details the agile fanzine creation procedure, the way problematic concepts were identified and quickly handled, and how this approach was implemented in an actual course, so it could be applied to other courses with similar needs.
Please see preprint version in: https://www.researchgate.net/publication/349522078_Improving_Concept_Learning_Through_Specialized_Digital_Fanzines
Youtube video of the presentation: https://www.youtube.com/watch?v=sfKerC5pAvw
The knowledge of the most common programming paradigms, and the basic abstractions provided by each paradigm, are competencies to be attained by Software Engineering undergraduate students. These abstractions also include the basis of concurrent and parallel programming, present in different programming paradigms. In an existing Software Engineering degree, these competencies were assigned to the Programming Technology and Paradigms course. We present the approach followed in the design of that course to teach object-oriented, functional, concurrent and parallel programming to second year undergraduate students with basic knowledge of Java. The time limitations of the course prevented us from using various programming languages. After analyzing different alternatives, we chose C# to teach the course. We describe the most important challenges faced and how we addressed them. The course success rate is slightly greater than the rest of courses in the same year and degree, while performance rates and average marks are analogous. There is no influence of age and gender on the final mark, but students retaking the course have significantly worse evaluation than those enrolled for the first time. The students’ self-evaluation revealed that the proposed course has a strong influence on the achievement of the expected learning outcomes, and their satisfaction with the course was significantly higher than with the rest of courses in the same degree.
Some programming languages such as CLOS, Xtend and Dylan provide multiple dispatch through multi-methods. Multiple dispatch is a language feature for dynamically determining the actual method to be executed, depending on the dynamic types of its arguments. However, many widespread languages such as Java, C# and C++ only support single dispatch by means of dynamic binding. For this reason, different implementation techniques are commonly used to obtain multiple dispatch in these single-dispatch programming languages. This paper proposes a new way to achieve multiple dispatch in hybrid static and dynamic typing languages, comparing it with the typical techniques used to simulate it. A qualitative comparison is presented, considering factors such as software maintainability and readability, code size, parameter generalization, and compile-time type checking. We have also performed a quantitative evaluation of runtime performance and memory consumption. The proposed approach provides parameter generalization, and high maintainability and readability. Its code size depends on neither the number of multi-method parameters nor the number of derived types. Runtime performance is, on average, analogous to runtime type inspection, 3.9 times slower than static typing, and 36.6 times faster than reflection. The proposed approach consumes 31% more memory resources than the rest of approaches.