Teaching Programming in the 21st Century

Although the teaching of programming has evolved over 50 years, all methodologies rely on a simple structure that was born a long time ago: the loop, shared by all high-level programming languages, and the preferred choice for any repetitive task programmers face. We analyze here how "loops&quo...

Full description

Saved in:
Bibliographic Details
Published in:The Journal of computer information systems 2023-07, Vol.63 (4), p.841-852
Main Author: de Vega, Francisco Fernández
Format: Article
Language:English
Subjects:
Computer networks
Computer programming
Distributed processing
Functional programming
High level languages
Loops
Maintainability
Parallel programming
Programmers
Programming languages
Programming methodologies
Teaching methods
Online Access:Get full text
Tags: Add Tag
No Tags, Be the first to tag this record!
cited_by
cites
container_end_page 852
container_issue 4
container_start_page 841
container_title The Journal of computer information systems
container_volume 63
creator de Vega, Francisco Fernández
description Although the teaching of programming has evolved over 50 years, all methodologies rely on a simple structure that was born a long time ago: the loop, shared by all high-level programming languages, and the preferred choice for any repetitive task programmers face. We analyze here how "loops" skew the way programmers solve problems, and prevent them from taking advantage of the available parallel/distributed computing architectures. To do so, we state our initial hypothesis: eliminating loops will allow a more natural parallel programming approach. The idea is to mimic a common practice today that was established in the past for a different purpose: prohibiting goto statements to improve code maintainability. This paper describes a new computer programming teaching strategy that we tested for 7 years and provides evidence on how loop prohibition, in the context of Functional Programming, makes students aware of data dependencies and produces 21st-century programmers who benefit from widely available parallel architectures.
doi_str_mv 10.1080/08874417.2022.2108934
format article
fullrecord <record><control><sourceid>proquest_infor</sourceid><recordid>TN_cdi_proquest_journals_2834350377</recordid><sourceformat>XML</sourceformat><sourcesystem>PC</sourcesystem><sourcerecordid>2834350377</sourcerecordid><originalsourceid>FETCH-LOGICAL-i857-8887cd6787f603f95399a5ac213d36a0d45684da014d8cbad3b64c99c00bf8773</originalsourceid><addsrcrecordid>eNo1kEtLxDAUhYMoWEd_glBw46b1Jjdp0p1SfMGALroPadLOdOhDkxaZf-_UGVfncvi4Bz5CbimkFBQ8gFKScypTBoyl7NDlyM9IxFBBwkDIcxItTLJAl-QqhB0AVQJ4RO7L2thtO2ziTz9uvOn75W6HeNrWMaNhiot6mGa_vyYXjelCfXPKFSlfnsviLVl_vL4XT-ukVUIm6jBjXSaVbDLAJheY50YYyyg6zAw4LjLFnQHKnbKVcVhl3Oa5BagaJSWuyN3x7Zcfv-c6THo3zn44LGqmkKMA_KMej1Q7NKPvzc_oO6cns-9G33gz2DZopKAXPfpfj1706JMe_AUq3lXe</addsrcrecordid><sourcetype>Aggregation Database</sourcetype><iscdi>true</iscdi><recordtype>article</recordtype><pqid>2834350377</pqid></control><display><type>article</type><title>Teaching Programming in the 21st Century</title><source>Taylor and Francis Science and Technology Collection</source><creator>de Vega, Francisco Fernández</creator><creatorcontrib>de Vega, Francisco Fernández</creatorcontrib><description>Although the teaching of programming has evolved over 50 years, all methodologies rely on a simple structure that was born a long time ago: the loop, shared by all high-level programming languages, and the preferred choice for any repetitive task programmers face. We analyze here how "loops" skew the way programmers solve problems, and prevent them from taking advantage of the available parallel/distributed computing architectures. To do so, we state our initial hypothesis: eliminating loops will allow a more natural parallel programming approach. The idea is to mimic a common practice today that was established in the past for a different purpose: prohibiting goto statements to improve code maintainability. This paper describes a new computer programming teaching strategy that we tested for 7 years and provides evidence on how loop prohibition, in the context of Functional Programming, makes students aware of data dependencies and produces 21st-century programmers who benefit from widely available parallel architectures.</description><identifier>ISSN: 0887-4417</identifier><identifier>EISSN: 2380-2057</identifier><identifier>DOI: 10.1080/08874417.2022.2108934</identifier><language>eng</language><publisher>Stillwater: Taylor &amp; Francis</publisher><subject>Computer networks ; Computer programming ; Distributed processing ; Functional programming ; High level languages ; Loops ; Maintainability ; Parallel programming ; Programmers ; Programming languages ; Programming methodologies ; Teaching methods</subject><ispartof>The Journal of computer information systems, 2023-07, Vol.63 (4), p.841-852</ispartof><rights>2022 International Association for Computer Information Systems 2022</rights><rights>2022 International Association for Computer Information Systems</rights><lds50>peer_reviewed</lds50><woscitedreferencessubscribed>false</woscitedreferencessubscribed></display><links><openurl>$$Topenurl_article</openurl><openurlfulltext>$$Topenurlfull_article</openurlfulltext><thumbnail>$$Tsyndetics_thumb_exl</thumbnail><link.rule.ids>314,780,784,27924,27925</link.rule.ids></links><search><creatorcontrib>de Vega, Francisco Fernández</creatorcontrib><title>Teaching Programming in the 21st Century</title><title>The Journal of computer information systems</title><description>Although the teaching of programming has evolved over 50 years, all methodologies rely on a simple structure that was born a long time ago: the loop, shared by all high-level programming languages, and the preferred choice for any repetitive task programmers face. We analyze here how "loops" skew the way programmers solve problems, and prevent them from taking advantage of the available parallel/distributed computing architectures. To do so, we state our initial hypothesis: eliminating loops will allow a more natural parallel programming approach. The idea is to mimic a common practice today that was established in the past for a different purpose: prohibiting goto statements to improve code maintainability. This paper describes a new computer programming teaching strategy that we tested for 7 years and provides evidence on how loop prohibition, in the context of Functional Programming, makes students aware of data dependencies and produces 21st-century programmers who benefit from widely available parallel architectures.</description><subject>Computer networks</subject><subject>Computer programming</subject><subject>Distributed processing</subject><subject>Functional programming</subject><subject>High level languages</subject><subject>Loops</subject><subject>Maintainability</subject><subject>Parallel programming</subject><subject>Programmers</subject><subject>Programming languages</subject><subject>Programming methodologies</subject><subject>Teaching methods</subject><issn>0887-4417</issn><issn>2380-2057</issn><fulltext>true</fulltext><rsrctype>article</rsrctype><creationdate>2023</creationdate><recordtype>article</recordtype><recordid>eNo1kEtLxDAUhYMoWEd_glBw46b1Jjdp0p1SfMGALroPadLOdOhDkxaZf-_UGVfncvi4Bz5CbimkFBQ8gFKScypTBoyl7NDlyM9IxFBBwkDIcxItTLJAl-QqhB0AVQJ4RO7L2thtO2ziTz9uvOn75W6HeNrWMaNhiot6mGa_vyYXjelCfXPKFSlfnsviLVl_vL4XT-ukVUIm6jBjXSaVbDLAJheY50YYyyg6zAw4LjLFnQHKnbKVcVhl3Oa5BagaJSWuyN3x7Zcfv-c6THo3zn44LGqmkKMA_KMej1Q7NKPvzc_oO6cns-9G33gz2DZopKAXPfpfj1706JMe_AUq3lXe</recordid><startdate>20230704</startdate><enddate>20230704</enddate><creator>de Vega, Francisco Fernández</creator><general>Taylor &amp; Francis</general><general>Taylor &amp; Francis Ltd</general><scope>4S-</scope><scope>4T-</scope><scope>JQ2</scope></search><sort><creationdate>20230704</creationdate><title>Teaching Programming in the 21st Century</title><author>de Vega, Francisco Fernández</author></sort><facets><frbrtype>5</frbrtype><frbrgroupid>cdi_FETCH-LOGICAL-i857-8887cd6787f603f95399a5ac213d36a0d45684da014d8cbad3b64c99c00bf8773</frbrgroupid><rsrctype>articles</rsrctype><prefilter>articles</prefilter><language>eng</language><creationdate>2023</creationdate><topic>Computer networks</topic><topic>Computer programming</topic><topic>Distributed processing</topic><topic>Functional programming</topic><topic>High level languages</topic><topic>Loops</topic><topic>Maintainability</topic><topic>Parallel programming</topic><topic>Programmers</topic><topic>Programming languages</topic><topic>Programming methodologies</topic><topic>Teaching methods</topic><toplevel>peer_reviewed</toplevel><toplevel>online_resources</toplevel><creatorcontrib>de Vega, Francisco Fernández</creatorcontrib><collection>BPIR.com Limited</collection><collection>Docstoc</collection><collection>ProQuest Computer Science Collection</collection><jtitle>The Journal of computer information systems</jtitle></facets><delivery><delcategory>Remote Search Resource</delcategory><fulltext>fulltext</fulltext></delivery><addata><au>de Vega, Francisco Fernández</au><format>journal</format><genre>article</genre><ristype>JOUR</ristype><atitle>Teaching Programming in the 21st Century</atitle><jtitle>The Journal of computer information systems</jtitle><date>2023-07-04</date><risdate>2023</risdate><volume>63</volume><issue>4</issue><spage>841</spage><epage>852</epage><pages>841-852</pages><issn>0887-4417</issn><eissn>2380-2057</eissn><abstract>Although the teaching of programming has evolved over 50 years, all methodologies rely on a simple structure that was born a long time ago: the loop, shared by all high-level programming languages, and the preferred choice for any repetitive task programmers face. We analyze here how "loops" skew the way programmers solve problems, and prevent them from taking advantage of the available parallel/distributed computing architectures. To do so, we state our initial hypothesis: eliminating loops will allow a more natural parallel programming approach. The idea is to mimic a common practice today that was established in the past for a different purpose: prohibiting goto statements to improve code maintainability. This paper describes a new computer programming teaching strategy that we tested for 7 years and provides evidence on how loop prohibition, in the context of Functional Programming, makes students aware of data dependencies and produces 21st-century programmers who benefit from widely available parallel architectures.</abstract><cop>Stillwater</cop><pub>Taylor &amp; Francis</pub><doi>10.1080/08874417.2022.2108934</doi><tpages>12</tpages></addata></record>
fulltext fulltext
identifier ISSN: 0887-4417
ispartof The Journal of computer information systems, 2023-07, Vol.63 (4), p.841-852
issn 0887-4417
2380-2057
language eng
recordid cdi_proquest_journals_2834350377
source Taylor and Francis Science and Technology Collection
subjects Computer networks
Computer programming
Distributed processing
Functional programming
High level languages
Loops
Maintainability
Parallel programming
Programmers
Programming languages
Programming methodologies
Teaching methods
title Teaching Programming in the 21st Century
url http://sfxeu10.hosted.exlibrisgroup.com/loughborough?ctx_ver=Z39.88-2004&ctx_enc=info:ofi/enc:UTF-8&ctx_tim=2024-12-27T22%3A45%3A43IST&url_ver=Z39.88-2004&url_ctx_fmt=infofi/fmt:kev:mtx:ctx&rfr_id=info:sid/primo.exlibrisgroup.com:primo3-Article-proquest_infor&rft_val_fmt=info:ofi/fmt:kev:mtx:journal&rft.genre=article&rft.atitle=Teaching%20Programming%20in%20the%2021st%20Century&rft.jtitle=The%20Journal%20of%20computer%20information%20systems&rft.au=de%20Vega,%20Francisco%20Fern%C3%A1ndez&rft.date=2023-07-04&rft.volume=63&rft.issue=4&rft.spage=841&rft.epage=852&rft.pages=841-852&rft.issn=0887-4417&rft.eissn=2380-2057&rft_id=info:doi/10.1080/08874417.2022.2108934&rft_dat=%3Cproquest_infor%3E2834350377%3C/proquest_infor%3E%3Cgrp_id%3Ecdi_FETCH-LOGICAL-i857-8887cd6787f603f95399a5ac213d36a0d45684da014d8cbad3b64c99c00bf8773%3C/grp_id%3E%3Coa%3E%3C/oa%3E%3Curl%3E%3C/url%3E&rft_id=info:oai/&rft_pqid=2834350377&rft_id=info:pmid/&rfr_iscdi=true