Un método gradual y general para entender por qué la programación funcional es importante
Palabras clave:
programación funcional, pensamiento denotacional, enseñanza de la programación, máquina notacional, GobstonesResumen
En el contexto actual, la programación sigue enseñándose predominantemente bajo un punto de vista imperativo, en el que los programas son concebidos como series de instrucciones ejecutables por computadoras. Sin embargo, la Programación Funcional (PF) propone una visión más amplia, que incluye a la anterior, pero la expande: los programas son descripciones computables. Incorporar esta visión en la formación de programadores requiere un enfoque pedagógico que no imponga la abstracción prematuramente, sino que la construya de forma progresiva. Este artículo presenta el trayecto pedagógico de una universidad pública argentina, un método gradual —que introduce conceptos de pureza de forma progresiva— y general —independiente de un lenguaje de programación particular—, diseñado para cerrar la brecha entre la formación académica y las demandas de la industria en torno a la producción de software de calidad, fundamentando cada etapa del método en la bibliografía relevante sobre enseñanza de la programación, programación funcional y didáctica de las ciencias de la computación. Complementariamente, se analiza por qué el pensamiento denotacional se vuelve especialmente relevante en la era de la IA Generativa, donde el rol del programador probablemente se desplace de la escritura a la especificación y verificación del código.
Descargas
Referencias
Aho, A. V., Hopcroft, J. E., & Ullman, J. D. (1983). Data structures and algorithms. Addison-Wesley.
Avgeriou, P., Kruchten, P., Ozkaya, I., & Seaman, C. (2016). Managing technical debt in software engineering. Dagstuhl Reports, 6 (4), 110-138. https: //doi.org/10.4230/DagRep.6.4.110
Backus, J. (1978). Can programming be liberated from the von Neumann style? A functional style and its algebra of programs. Communications of the ACM, 21 (8), 613-641. https://doi.org/10.1145/359576.359579
Barr, M., & Wells, C. (1995). Category theory for computing science. Prentice Hall.
Bird, R., & Wadler, P. (1988). Introduction to functional programming. PrenticeHall.
Bragilevsky, V. (2021). Haskell in depth. Manning Publications.
Brooks, F. P. (1987). No silver bullet: Essence and accidents of software engineering. Computer, 20 (4), 10-19. https://doi.org/10.1109/MC.1987.1663532
Chapman, P. (2025). Experiences of early assessment to teach functional programming. Journal of Functional Programming, 35 (4). https://doi.org/10.1017/S0956796824000182
CodeRabbit. (2025). State of AI vs human code generation report. https://www.coderabbit.ai/blog/state-of-ai-vs-human-code-generation-report
Cormen, T. H., Leiserson, C. E., Rivest, R. L., & Stein, C. (2009). Introduction to algorithms (3.a ed.). MIT Press.
Cummins, C., Fisches, Z. V., Ben-Nun, T., Hoefler, T., O’Boyle, M., & Leather, H. (2021). PROGRAML: A graph-based program representation for data flow analysis and compiler optimizations. En M. Meila & T. Zhang (Eds.), Proceedings of the 38th International Conference on Machine Learning (pp. 2244-2253, Vol. 139). PMLR.
Cunningham, W. (1992). The WyCash portfolio management system. En Addendum to the Proceedings of OOPSLA ’92 (pp. 29-30). ACM. https://doi.org/10.1145/157709.157715
Dijkstra, E. W. (1989). On the cruelty of really teaching computing science (Manuscrito N.o EWD1036). https://www.cs.utexas.edu/~EWD/ewd10xx/EWD1036.PDF Transcripción: https://www.cs.utexas.edu/~EWD/transcriptions/EWD10xx/EWD1036.html.
Du, X., Liu, M., Wang, K., Wang, H., Liu, J., Chen, Y., Feng, J., Sha, C., Peng, X., & Lou, Y. (2024). Evaluating large language models in classlevel code generation. En ICSE ’24: Proceedings of the IEEE/ACM 46th International Conference on Software Engineering (pp. 1-13). IEEE. https://doi.org/10.1145/3597503.3639219
Du Boulay, B. (1986). Some difficulties of learning to program. Journal of Educational Computing Research, 2 (1), 57-73. https://doi.org/10.2190/3LFX9RRF-67T8-UVK9
Ehrig, H., & Mahr, B. (1985). Fundamentals of algebraic specification 1: Equations and initial semantics. Springer-Verlag.
Féjer, P. A., & Simovici, D. A. (1991). Mathematical foundations of computer science, Volume I: Sets, relations, and induction. Springer-Verlag.
Felleisen, M., Findler, R. B., Flatt, M., & Krishnamurthi, S. (2004). The TeachScheme! project: Computing and programming for every student. Computer Science Education, 14 (1), 55-77. https://doi.org/10.1076/csed.14.1.55.23499
Felleisen, M., Findler, R. B., Flatt, M., & Krishnamurthi, S. (2018). How to design programs: An introduction to programming and computing (2.a ed.). MIT Press.
Grätzer, G. (2008). Universal algebra (2.a ed.). Springer-Verlag.
Gunter, C. A. (1992). Semantics of programming languages: Structures and techniques. MIT Press.
Hu, Z., Hughes, J., & Wang, M. (2015). How functional programming mattered. National Science Review, 2 (3), 349-370. https://doi.org/10.1093/nsr/nwv042
Hughes, J. (1989). Why functional programming matters. The Computer Journal, 32 (2), 98-107. https://doi.org/10.1093/comjnl/32.2.98
Hutton, G. (1999). A tutorial on the universality and expressiveness of fold. Journal of Functional Programming, 9 (4), 355-372. https://doi.org/10.1017/S0956796899003500
Jeuring, J., & Meijer, E. (Eds.). (1995). Advanced functional programming: First international spring school on advanced functional programming techniques (Vol. 925). Springer. https://doi.org/10.1007/3-540-59451-5
Joosten, S., Van Den Berg, K., & Van Der Hoeven, G. (1993). Teaching functional programming to first-year students. Journal of Functional Programming, 3 (1), 49-65. https://doi.org/10.1017/S0956796800000599
Kaminski, J. A., Heckler, A. F., & Sloutsky, V. M. (2006). Do children need concrete instantiations to learn an abstract concept? En R. Sun & N. Miyake (Eds.), Proceedings of the 28th Annual Conference of the Cognitive Science Society (pp. 411-416, Vol. 28). Psychology Press.
Kernighan, B. W., & Plauger, P. J. (1978). The elements of programming style (2.a ed.). McGraw-Hill.
Kernighan, B. W., & Ritchie, D. M. (1988). The C programming language (2.a ed.). Prentice-Hall.
Lister, R., Adams, E. S., Fitzgerald, S., Fone, W., Hamer, J., Lindholm, M., McCartney, R., Moström, J. E., Sanders, K., Seppälä, O., Simon, B., & Thomas, L. (2004). A multi-national study of reading and tracing skills in novice programmers. ACM SIGCSE Bulletin, 36 (4), 119-150. https://doi.org/10.1145/1041624.1041673
Mannila, L. (2010). Invariant based programming in education: An analysis of student difficulties. Informatics in Education, 9 (1), 115-132. https://doi.org/10.15388/infedu.2010.07
Martínez López, P. E. (2021). Programar es mucho más que secuenciar comandos. En Boari et al. (Eds.), Actas de las 1eras Jornadas Argentinas de Didáctica de Ciencias de la Computación (JADiCC’21) (pp. 191-204). https://jadicc.program.ar/wp-content/uploads/2022/03/actas-jadicc2021.pdf
Martínez López, P. E., Bonelli, E. A., & Sawady O’Connor, F. A. (2012). El nombre verdadero de la programación: Una concepción de enseñanza de la programación para la sociedad de la información. En Actas del 10° Simposio sobre la Sociedad de la Información (SSI), 41 JAIIO (pp. 1-23). SADIO.
Martínez López, P. E., Ciolek, D., Arévalo, G., & Pari, D. (2017). The Gobstones method for teaching computer programming. En XXV Simposio de Educación Superior en Computación (SIESC’17), dentro de la XLIII Conferencia Latinoamericana de Informática (CLEI’17). IEEE.
Núñez, M., Palao, P., & Peña, R. (1995). A second year course on data structures based on functional programming. En P. H. Hartel & R. Plasmeijer (Eds.), Functional Programming Languages in Education. FPLE 1995 (Vol. 1022). Springer. https://doi.org/10.1007/3-540-60675-0_39
Okasaki, C. (1998). Purely functional data structures. Cambridge University Press. https://doi.org/10.1017/CBO9780511530104
Papert, S. (1980). Mindstorms: Children, computers, and powerful ideas. Basic Books.
Perkins, D. N., & Salomon, G. (1992). Transfer of learning. En T. Husén & T. N. Postlethwaite (Eds.), International encyclopedia of education (2.a ed.). Pergamon Press.
Pierce, B. C. (1991). Basic category theory for computer scientists. MIT Press.
Pierce, B. C. (2002). Types and programming languages. MIT Press.
Plotkin, G. D., & Pretnar, M. (2013). Handling algebraic effects. Logical Methods in Computer Science, 9 (4), 1-36. https://doi.org/10.2168/LMCS-9(4:23)2013
Resnick, M., Maloney, J., Monroy-Hernández, A., Rusk, N., Eastmond, E., Brennan, K., Millner, A., Rosenbaum, E., Silver, J., Silverman, B., & Kafai, Y. (2009). Scratch: Programming for all. Communications of the ACM, 52 (11), 60-67. https://doi.org/10.1145/1592761.1592779
Reynolds, J. C. (1998). Theories of programming languages. Cambridge University Press.
Risko, E. F., & Gilbert, S. J. (2016). Cognitive offloading. Trends in Cognitive Sciences, 20 (9), 676-688. https://doi.org/10.1016/j.tics.2016.07.002
Ruiz Martín, H. (2020). ¿Cómo aprendemos? Una aproximación científica al aprendizaje y la enseñanza (2.a ed.). Editorial Graó.
Scholl, P. C., & Peyrin, J. P. (1988). Schémas algorithmiques fondamentaux: Séquences et itération. Masson.
Schwartz, M. S., Sadler, P. M., Sonnert, G., & Tai, R. H. (2009). Depth versus breadth: How content coverage in high school science courses relates to later success in college science coursework. Science Education, 93 (5), 798-826. https://doi.org/10.1002/sce.20328
Sentance, S., Barendsen, E., & Schulte, C. (Eds.). (2018). Computer science education: Perspectives on teaching and learning in school. Bloomsbury Academic.
Tihanyi, N., Bisztray, T., Ferrag, M. A., Jain, R., & Cordeiro, L. C. (2025). How secure is AI-generated code: A large-scale comparison of large language models. Empirical Software Engineering, 30 (2), Artículo 47. https://doi.org/10.1007/s10664-024-10590-1
Wadler, P. (1992). The essence of functional programming. En Proceedings of the 19th ACM SIGPLAN-SIGACT Symposium on Principles of Programming Languages (POPL ’92) (pp. 1-14). ACM. https://doi.org/10.1145/143165.143169
Wadler, P. (2015). Propositions as types. Communications of the ACM, 58 (12), 75-84. https://doi.org/10.1145/2699407
Wang, Z., Zhou, Z., Song, D., Huang, Y., Chen, S., Ma, L., & Zhang, T. (2025). Towards understanding the characteristics of code generation errors made by large language models. En Proceedings of the IEEE/ACM 47th International Conference on Software Engineering (ICSE ’25) (pp. 2587-2599). IEEE. https://doi.org/10.1109/ICSE55347.2025.00180
Welsh, M. (2023). The end of programming. Communications of the ACM, 66 (1), 34-35. https://doi.org/10.1145/3570220
Descargas
Publicado
Número
Sección
Licencia
Derechos de autor 2026 Federico A. Sawady O’Connor, Pablo E. Martínez López, Magdalena Garzón
Esta obra está bajo una licencia internacional Creative Commons Atribución-NoComercial-CompartirIgual 4.0.
Acorde a estos términos, el material se puede compartir (copiar y redistribuir en cualquier medio o formato) y adaptar (remezclar, transformar y crear a partir del material otra obra), siempre que a) se cite la autoría y la fuente original de su publicación (revista y URL de la obra), b) no se use para fines comerciales y c) se mantengan los mismos términos de la licencia.
