Recent news suggests that the advent of AI-generated coding tools signal the end of humans programming. This news should not, however, suggest that students not learn how to program but instead that instructors rethink how they teach programming. Math education has already addressed the challenge of teaching fluency when there is technology for basic tasks by having students use multiple representations, different approaches, and explanations of others' work to emphasize problem-solving, critical thinking, and communication while still teaching basic skills. These approaches can also be applied to computer science education, especially in an introductory course, and with the same benefits.

**Introduction**

A student in my introductory computer science course came to my office in December 2022, to show me a new website that used artificial intelligence (AI) to write Python code. Excitedly, he showed me how it wrote efficient code for two of our assignments that semester and key subroutines for many others. It was amazing; it was horrifying. It is difficult enough to create assignments that cannot be copied from the internet, now must we deal with this tool? Soon, however, I began to wonder: If AI-created code is the future of computer science [25], how do we teach our beginner courses to prepare them for both the transition to and the immersion in this future? To answer that question, I suggest we look to mathematics education for ideas.

Math and computer science are closely related disciplines, according to Convergent Cognition Theory [20]. In simple terms, "Computer science inherently draws on mathematical thinking." [26: 35] Typically, the research uses this relationship by applying computer science pedagogy to math education [e.g., 1,9,11,19,23]. Convergent Cognition Theory, however, states that the relationship between math and computer science is reciprocal [20]; therefore, one should be able to apply math pedagogy to computer science education.

Knowingly or unknowingly, we already use math education ideas in computer science. CS Unplugged^{1} and related activities are examples of math education's concrete-representational-abstract instructional approach, which is a teaching method that emphasizes the use of hands-on activities with physical manipulatives, followed by applying the concept to images, followed by symbolic representations such as equations [3]. Other teaching strategies common to both math and computer science education include:

- problem-based learning—where students are given an open-ended challenge to solve,
- game-based learning—where students explore concepts through games or game development, and
- project-based learning—where students apply their learning to real-world problems.

If we look more closely at what math education is doing, we can improve computer science education while making use of AI code generators in our classrooms.

The purpose of this article is not to provide strategies that prevent students from using AI tools in place of learning, but rather to help instructors use these tools to improve novice programmers' critical thinking skills. As AI improves, preventing or detecting cheating on programming assignments will increase in difficulty, but so will AI's importance to computer science professionals. Understanding when and how to use AI is something we can teach, just as math instructors teach students to use technology critically.

• **What Happens in Math Education**

If we examine today's math classes up to and including calculus, we observe students practicing mental arithmetic, graphing lines on paper, and solving equations by hand. Why, one might ask do they do this, when we have affordable tools that will do this work for us? Fluency with these procedures helps students reduce cognitive load when solving more complex problems, gain multiple approaches to problem solving, better assess the reasonableness of solutions, and develop critical thinking skills [2,14,22]. So how does math education develop these skills while still making the learning relevant to student? It asks different questions than what many of us were asked in school. Specifically, math education today asks students to work with multiple representations, experiment with different approaches, and explain someone else's solution to a problem.

• **Working with Multiple Representations**

The National Research Council suggests, "A significant indicator of conceptual understanding is being able to represent mathematical situations in different ways and knowing how different representations can be useful for different purposes." [18: 119]. These representations can include drawing diagrams or images, handling concrete objects, creating/reading tables, expressing in words, or using symbols [17,18]. Understanding the strengths and weaknesses of various representations is considered an essential tool for mathematical problem solving as well as a means for understanding mathematical procedures [17].

Many of us are familiar with the use of tables in algebra, pictures in geometry, and physical blocks in arithmetic. We have used or seen them used as precursors to the symbolic representation of an equation, such as graphing a line from numeric data before learning the equation, y = mx + b. Today, however, teachers are using representations in math differently. They may give the students a symbolic expression, such as 2/5 + 4/7, then ask students to draw a picture representing the symbols or to work the expression into a story problem. By using multiple representations, teachers help students build a deeper understanding of mathematical concepts by connecting them to different ways of thinking about the same idea. Additionally, students can see the connections between different representations and develop a more holistic understanding of the subject.

• **Experimenting with Different Approaches**

Math education often encourages students to experiment with multiple approaches by providing them with a variety of problem-solving strategies and encouraging them to apply the different methods to solve the same problem, which helps students develop a deeper understanding of the concepts and develop their own problem-solving skills [27]. Additionally, teachers may also provide opportunities for students to work on open-ended or real-world problems that require them to use multiple approaches to find a solution, which can help students see the connections between different mathematical concepts and develop a more holistic understanding of the subject [12].

As a simple example, a teacher might introduce different methods for solving a quadratic equation, such as factoring, completing the square, or using the quadratic formula, and then have students try each method, compare the results, and discuss their strengths and weaknesses. Alternatively, teachers could provide students a messier problem, such as estimating the volume of water in a local lake, allow students to work the problem using approaches of their own choosing, then as a class discuss the various approaches. Either way, working with multiple approaches helps students develop creativity and flexibility in problem-solving [12] as they increase their mathematical understanding.

• **Explaining Someone Else's Solution**

Traditionally, math educators have asked students to explain their own reasoning when solving a math problem, but in recent years they have also asked students to explain someone else's reasoning. By explaining a solution other than their own, students must be able to understand the reasoning and logic behind the solution, which can help them develop a deeper understanding of the underlying mathematical concepts, develop critical thinking, and expose any misconceptions they may have [13,21]. Meanwhile, it develops metacognition skills in the student, as they will be reflecting on the problem-solving process and their own understanding of the solution, and communication skills in mathematics [15].

In recent years, K-12 math has added a new type of problem for students to consider. These problems show a completely worked-out math solution that may or may not be correct. Students are then asked to explain the reasoning behind that solution, to determine if the solution is correct and why or why not, or to compare that solution with another complete solution. For example, the problem might state that some fictional student solved 5 – (-2) by simplifying it to 5 – 2 and getting 3 as an answer, then the problem asks if this student is correct and to either explain the student's reasoning or where the student went wrong.

These three methods (explain someone else's reasoning, experiment with different approaches, use multiple representations) diversify how students today look at a math problem. Such diversification increases their critical thinking skills while developing the core fluency needed for higher mathematics [27], which then allows students to use math technology with intent and insight [7]. Additionally, these approaches often integrate technology as instructional tools to support developing fluency rather than replace it [10]. It is therefore reasonable to assume, based on Convergent Cognition Theory [20], that a similar approach would help beginning computer science students.

**Applying Math Pedagogy to Computer Science Education**

As the prior section demonstrated, math education has been moving more towards critical thinking and problem-solving. Computer science education, one may argue, has already been there. After all, we already use a problem-solving approach when we ask students to design algorithms or debug code. If, however, tools like ChatGPT are simplifying the problem-solving process for us, such as when writing programs for a given problem-statement, then we as educators will need to diversify our approach just as mathematics has done.

• **Multiple Representations in CS**

Computer scientists regularly engage with multiple representations to represent data and concepts, making them more accessible, understandable, and actionable [16]. Each type of representation accents different information about the problem and the algorithms or data structures needed in the solution [4]. These representations can include the following:

- textual representations—algorithms written in a programming language or pseudocode,
- visual representations—UML diagrams and other visual aids, and
- numerical representations—numbers and mathematical formulas describing data.

Classrooms have also used these representations to teach difficult concepts. One example of using multiple representations in computer science education is teaching the concept of a linked list data structure. Such a lesson would begin with a physical demonstration using interlocking beads to demonstrate what is meant by "linked," followed by diagrams explaining the common parts of a linked list; both of these could be considered visual representations. This introduction to the concept could then be extended using code implementing a linked list (textual representation) that shows how the memory addresses of the elements are linked together (numerical representation).

The more students interact with these representations, however, the greater their understanding develops [6]. One approach to increase student interaction would be to ask students to generate code in ChatGPT then explain that code by drawing an activity diagram and showing how the data change as the program executes. For example, ChatGPT generates a Python program that reverses the digits in an integer and provides a written explanation of the code (Figure 1), both considered textual representations. The students would then create an activity diagram or flow chart for a visual representation, as seen in Figure 2, and could follow this work with numerical representation by showing how the variables' values change as the code executes.

Like the math teacher who asks students to represent an equation using pictures and words, as described in the previous section, starting with the code then working backwards to the design and forward to the expected data changes would connect students to different ways of thinking about the same idea. Including other representations, such as pseudocode, would also help students identify how each highlights different information about the algorithm, how each can be used to communicate with different stakeholders of a project, and which can be used to identify possible errors in the code [4].

• **Using Different Approaches in CS**

For students new to coding, asking them to develop multiple solutions to a problem may be a daunting task. They use so much effort developing their first solution that they may not be able to envision any other approach to the problem [8]. In mathematics, however, knowing multiple approaches to a problem is considered so important that teachers explicitly teach them with each major concept, such as the different ways to find the roots of a quadratic function. Over the course of a computer science major's education, they do examine multiple sorting algorithms and data structures, which are different approaches to solving common problems, but it is likely that less of this strategy is used in an introductory CS course.

Using Al-generated code can be a valuable tool for students to examine multiple approaches to a programming problem. They could use an AI code generation tool to generate multiple solutions then compare the solutions, focusing on the differences in approach, style, and efficiency. Similarly, they could compare the generated code to a human-created solution, which would also allow them to compare readability and maintainability of the solutions. Finally, they could generate one solution using AI then write their own that solves the same problem but in a different way. For example, ChatGPT generated the solution shown in Figure 3 for performing a Caesar shift.

When asked to create an alternate approach, one student wrote the following code:

`alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"`

`def cipherShift (line, shift):`

arrLine = list (line)

numChars = len (arrLine)

numCharsCount = 0

traverse = 0

if (shift == 0):

print ("Ciphertext: " + line)

return

i = 0

while (numCharsCount < numChars) and (i < 26):

if (arrLine[traverse] == alphabet[i]):

if (i + shift >= 26):

shift = shift - 26

arrLine[traverse] = alphabet[i + shift]

traverse += 1

i = -1

numCharsCount += 1

if (traverse >= numChars):

output = ""

for z in range (numChars):

output += (arrLine[z])

print ("Shift = {}: {}".format (shift, output))

return

elif (arrLine[traverse].isalpha() == False):

traverse += 1

i = -1

numCharsCount += 1

i += 1

Creating a different approach not only requires students to be able to understand the solution generated by the AI but also to be able to examine a problem from multiple perspectives [8]. Thus, having AI-generated code facilitates examining multiple solutions to problems without requiring that students (or instructors) develop these different solutions themselves.

• **Explaining an AI-Generated Solution**

We typically give students a scenario, expressed without technical language, and ask them to develop a solution that they then translate to a programming language. Explaining an AI-generated solution is asking students to do the reverse: Translate a programming language to a non-technical language that describes what the program does and how it accomplishes its task. When students are asked to explain code without using technical language, they are forced to think critically about the code and consider what it does and why it works the way it does [24]. This may lead to a deeper understanding of the code and the concepts behind it while developing students' communication skills for explaining technical concepts to non-technical audiences. Explaining code without technical language reveals what one truly understands about the algorithm and reveals areas of misunderstanding or incomplete understanding [5]. Explaining the code can also increase student engagement and problem-solving skills when we ask them to identify any potential issues or weaknesses in the code and how to improve the solution [8].

As an example, students could use AI-generated code as a starting point, identify potential weaknesses, then refine and improve the code. Figure 4 shows two Python solutions generated by ChatGPT for determining if a string is a palindrome.

After testing and learning the logic of each, students can time the execution of each function using a list of words to determine which is more efficient. Students could then be asked if either of them would recognize "Never odd or even" as a palindrome and, if not, which would be easier to modify for handling phrases.

Explaining an AI-generated solution can lead to improved understanding of the code and the concepts behind it. When students are asked to explain code, they are forced to engage with the code on a deeper level, which can help them better understand the syntax, logic, and structure of the programming language [24]. Additionally, asking students to examine their explanations to identify any weaknesses in the algorithm also teaches them to critically evaluate any code they may find online or from a peer. Too often students find code elsewhere without knowing how to determine its accuracy and suitability to the problem they are trying to solve, or what vulnerabilities the code may introduce into their project. AI-generated code could be a relevant tool for introducing beginning programmers to critically examining other people's solutions.

**Example Assignments Using ChatGPT**

Prior to ChatGPT, my department asked students in our introductory course to write a program that would count the number of times the digit "0" would appear if you counted from one to a number provided by the user. Thankfully, ChatGPT went live just after this program was due because this assignment is exactly the kind of task AI-generated code currently excels at. However, the completeness and efficiency of the solution one gets depends on how one phrases their question. When I asked ChatCPT on January 29th, 2023, to "create a python program that counts the times that zero appears in all of the numbers from 1 to a given input," the following code resulted:

`def count_zeros(n):`

count = 0

for i in range(1, n+1):

num = i

while num < 0:

if num % 10 a== 0:

count += 1

num = num // 10

return count

Three days earlier, however, resulted in this different approach:

`def count_zeros(n) :`

count = 0

for i in range (1, n+1):

count += str(i).count('0')

return count

Five days before that last solution, ChatGPT offered a sub-routine that only counted the ending zeros and not zeros found in the middle of a number, such as in "101."

These different answers informed how the assignment needed to be changed. The original assignment simply asked students to develop the program. The updated version still has students write code, but it also has them interact with multiple representations, explain the code generated by the AI, and compare multiple approaches. What follows is the assignment as it is shared with students and a second assignment that begins with AI-generated code then asks students to modify it:

• **Sample Assignment I**

**Goal of this assignment:** ChatGPT and its predecessor, OpenAI playground, can write programs when given a simple description or set of comments. But how good is the code? And do we understand what the code is doing? After all, if we're going to start using tools like these, we had better start with learning their strengths and weaknesses. To begin, we're going to consider a simple problem: If you were to write all the numbers from 1 to X, how many zeros would you draw? For example, if you want the numbers from 1 to 101, you would draw 12 zeros: 10, 20, 30, 40, 50, 60, 70, 80, 90, 100 (2 zeros), and 101.

In this assignment, you are going to have ChatGPT write your program for you, and you will draw a flow chart to describe the logic of it. You will then test that program with various inputs to see if it truly solves the problem, and you will examine the logic to determine if it solved the problem efficiently. Finally, you will adjust as needed and turn in a program that fully and efficiently solves the problem.

Note: Not everyone will have the same result for this assignment. OpenAI can give different programs for the same problem, usually because people pose the problem differently, which will affect how you address the various parts of this assignment.

**ChatGPT and OpenAI:** OpenAI is a company that has been playing around with using artificial intelligence to transform natural language prompts into images, essays, and computer programs. At first, it allowed the public to use their AI in what's known as the Playground (https://beta.openai.com/playground), but then in November 2022, it upgraded that to ChatGPT (https://chat.openai.com/chat). Both are free to use, and both work off the same AI platform—one just has a nicer user interface and a few extra features. In both cases, however, you can use them to write whatever you need to write.

For example, go to the Playground and type, "Write a Python program that determines if a number is even or odd" then click "Submit"—you will get a program like one we wrote in class this semester. Now go to ChatGPT and type the same thing. In this version, not only will you get the program, but you will also get a brief explanation on how the program works. There are other differences between them, but we will save that for another assignment.

• **The Assignment Tasks:**

- Go to ChatGPT or OpenAI Playground (your choice) and have it generate a program that will count the zeros from 1 to a number input by the user.
- Draw a flowchart describing the logic that this program uses.
- Test the resulting program to determine if it works for several values. Test cases and expected answers will be provided. If the program does not work for everything, fix the program. Add to your flowchart what you did to fix it. If the program does work for everything, describe (on your flowchart) why it works for any number.
- One way to solve this problem is to change the number into a String and use a String method. Is that faster or slower than starting with the input number as an integer? You are about to find out. If your AI code turns the number into a String, write a subroutine that counts the zeros from 1 to the user input while keeping the input as an integer. If your AI code keeps the number as an integer, write a subroutine that counts the zeros from 1 to the user input by casting the number as a string. In both cases, get the input from the user, time how long it takes to run each subroutine (keep as int vs turn to str), test using at least twenty integers of varying magnitudes. Add a comment at the end of your program stating which was faster and why you think it was faster.

• **Sample Assignment II**

**Introduction and goal of this assignment:** You have probably learned by now that charging too much on a credit card can leave you in debt for a long time, but what exactly does that mean? How long is long? I asked ChatGPT to write a program that calculates what one owes on a credit card, and it generated the following program:

`balance = float (input ("Enter the outstanding balance on your credit card: "))`

interest_rate = float (input ("Enter the annual interest rate (as a decimal): "))

monthly_payment = float (input ("Enter the minimum monthly payment (as a decimal): "))

months = int (input ("Enter the number of months you want to calculate: "))

total_amount_paid = 0

for i in range (months):

interest = balance * (interest_rate/12)

balance += interest

balance -= monthly_payment

total_amount_paid += monthly_payment

print ("Month:", i+1)

print ("Minimum monthly payment: $", round (monthly_payment, 2))

print ("Principle paid: $", round (monthly_payment - interest, 2))

print ("Remaining balance: $", round (balance, 2))

print ("Total amount paid: $", round (total_amount_paid, 2))

print ("Remaining balance: $", round (balance, 2))

It's a good program, but it doesn't tell us how long it will take to pay off the debt. Your task is to create a program that will determine how many months it will take to pay off a credit card (assuming that there are no additional charges to that card).

• **The Assignment Tasks:**

- Before you can modify a program, you need to fully understand how it works, so draw a flowchart or write the pseudocode explaining the program created by ChatGPT.
- Modify this program so that the monthly calculations are done in a subroutine.
- In our program, we don't really care about the month-by-month results, so remove those print statements and change your program so that it calculates and outputs how many months it will take to get the balance down to 0. Assume you will pay the same amount each month and be aware that the final payment might be less that what the other payments are.
- Test your program with an initial debt of $10,000, interest rates of 19.94%, 23.65% and 19.07% (all typical rates for this year), and various monthly payments, like $100, $50, and $175.

• **Assessing Student Learning**

For both assignments, students are asked to submit a flow chart with all changes or write-ups on it and their Python file. For the first assignment, the Python file should include the AI-generated subroutine, their alternate subroutine, their testing code, and their comment about which was faster and why. The Python code for the second assignment includes only their modifications and comments. The flow chart, a visual representation of the code, assesses students' abilities to read Python code, to comprehend what they read, and to analyze an algorithm for completeness. The Python file assesses students' skills with generating / comparing alternate solutions. The comment at the end of the first assignment assesses student's ability to apply knowledge they have been gaining throughout the course, which is how variables and functions are processed by the computer, to hypothesize about a scenario they likely have not considered previously, which is why there is an execution-time difference between an integer-based solution and a String-based solution. The second assignment reinforces programming skills they have learned previously and can serve as an introductory scenario for recursion.

Matt Welsh claims we are about to see the end of programming thanks to the dawn of AI-generated code. If that is true, at the very least we have a responsibility to prepare our students for this transition.

• **Future Directions**

As students progress in their computer science courses, the incorporation of AI tools and math pedagogy could continue. For example, students in a more advanced course could write a program, ask ChatGPT to optimize it for speed, then explain what changed and why performance improved using big-O notation. Similarly, they can ask the AI for three approaches for writing a program that addresses a real-world problem, such as analyzing text, then discuss or model the benefits and difficulties of each. Students are again generating/considering alternate approaches, explaining someone else's solution, and using multiple representations, but with ideas that are closer to those they will be required to consider as computer science professionals.

**Conclusion**

Matt Welsh [25] claims that we are about to see the end of programming thanks to the dawn of AI-generated code. If that is true, at the very least we have a responsibility to prepare our students for this transition. Specifically, we need to consider how to develop good programmers while still acknowledging and engaging with these new tools for programming. However, the recent history of math education and their struggle with technology suggests that fluency, which includes basic skills, is important regardless of the tools available. When applied to computer science education, this history suggests that students should still learn programming fluency in order to develop problem-solving and critical thinking skills, to reduce cognitive load when working on more advanced problems, and to assess the effectiveness of these AI-generated solutions. Math education history also suggests, however, that we need to rethink our approach to introductory CS courses not only to keep the material relevant to students but to also accentuate the cognitive benefits of learning to code. Since math and computer science are so closely related [20, 26], adapting math instructional techniques to our CS courses would be an effective approach. Future studies may reveal what students and instructors gain from this integration.

**Acknowledgements**

Portions of this article were written using ChatGPT; specifically, ChatGPT generated examples for the "What Happened in Math Education" section and assisted with phrasing the author's ideas throughout the paper.

**References**

1. Aydin, E. The use of computers in mathematics education: A paradigm shift from "computer aided instruction" towards "student programming." *The Turkish Online Journal of Educational Technology*, 4, 2 (2005).

2. Bay-Williams, J.M., and San Giovanni, J.J. *Figuring Out Fluency in Mathematics Teaching and Learning, Grades K-8: Moving Beyond Basic Facts and Memorization.* (Corwin, 2021).

3. Berry, R.Q. & Thunder, K. Concrete, representational, and abstract: Building fluency from conceptual understanding. *Virginia Mathematics Teacher*, 43, 2 (2017), 28–32.

4. Blackwell, A.F., Whitley, K.N., Good, J., and Petre, M. Cognitive factors in programming with diagrams. *Artificial Intelligence Review*, 15, 1 (2001), 95–114.

5. Corney, M., Fitzgerald, S., Hanks, B., Lister, R., McCauley, R., and Murphy, L. 'Explain in plain English' questions revisited: Data structures problems. *Proceedings of the 45th ACM Technical Symposium on Computer Science Education* (2014), 591–596.

6. Fouh, E., Akbar, M., and Shaffer, C.A. The role of visualization in computer science education. *Computers in the Schools*, 29, 1–2 (2012), 95–117.

7. Geraniou, E., and Jankvist, U.T. Towards a definition of "mathematical digital competency." *Educational Studies in Mathematics*, 102, 1 (2019), 29–45.

8. Gomes, A. and Mendes, A.J. Learning to program-difficulties and solutions. In *International Conference on Engineering Education-ICEE*, 7 (2007, September).

9. Harel, I. and Papert, S. Software design as a learning environment. *Interactive Learning Environments*, 1 (1990), 1–32.

10. Hopker, E., Atherfold, R., Bartlett, T., Ibrahim, M., Lynch, C., de Carvalho, C.P., Radmehr, M. and Sureshbabu, L. Exploring the use of technology and teacher confidence to develop and support teaching and learning with variation for fluency in 16-19-year-old GCSE maths re-sit learners, within different learning environments. *Centres for Excellence in Maths* (2021). https://www.et-foundation.co.uk/wp-content/uploads/2021/10/31.-Newham-Use-of-technology-and-teacher-confidence.pdf Accessed 2023 January 21.

11. Kafai, Y. Software by kids for kids. *Communications of the ACM*, 39, 4 (1996), 38–39.

12. Khalid, M., Saad, S., Hamid, S.R.A., Abdullah, M.R., Ibrahim, H., and Shahrill, M. Enhancing creativity and problem solving skills through creative problem solving in teaching mathematics. *Creativity Studies*, 13, 2 (2020), 270–291.

13. Laursen, S.L., and Rasmussen, C. I on the prize: Inquiry approaches in undergraduate mathematics. *International Journal of Research in Undergraduate Mathematics Education*, 5 (2019), 129–146.

14. Lin, X. Investigating the unique predictors of word-problem solving using meta-analytic structural equation modeling. *Educational Psychology Review*, 33, 3 (2021), 1097–1124.

15. Manfre, J. How to promote productive discussion in math. *Edutopia* (2020, Mar. 27); https://www.edutopia.org/article/how-promote-productive-discussion-math/ Accessed 2023 January 21.

16. Mirolo, C., Izu, C., Lonati, V., and Scapin, E. Abstraction in Computer Science Education: An Overview. *Informatics in Education*, 20, 4 (2022), 615–639.

17. National Council of Teachers of Mathematics. *Principles to Actions: Ensuring Mathematical Success for All.* (Reston, VA: NCTM, 2014).

18. National Research Council. *Adding It Up: Helping Children Learn Mathematics.* (Washington, DC: The National Academies Press, 2001); https://doi.org/10.17226/9822.

19. Popat, S., and Starkey, L. Learning to code or coding to learn? A systematic review. *Computers and Education*, 128 (2019), 365–376.

20. Rich, P., Bly, N., and Leatham, K. Beyond cognitive increase: Investigating the influence of computer programming on perception and application of mathematical skills. *Journal of Computers in Mathematics and Science Teaching*, 33, 1 (2014), 103–128.

21. Rittle-Johnson, B, and Star, J.R. Does comparing solution methods facilitate conceptual and procedural knowledge? An experimental study on learning to solve equations. *Journal of Educational Psychology*, 99, 3 (2007), 561–574.

22. Rushton, S.J., Hadley, K.M., and Stewart, P.W. Mathematics fluency and teaching self-efficacy of teacher candidates. *Journal of the International Society for Teacher Education*, 20, 2 (2016), 48–56.

23. Tilford, M.P. Achievement in algebra II using computer programming. *SIGCUE Outlook*, 13, 2 (1979), 9–14.

24. Vieira, C., Magana, A., Falk, M., and Garcia, R. Writing in-code comments to self-explain in computational science and engineering education. *ACM Transactions on Computing Education*, 17, 4 (2017), 1–21. https://doi.org/10.1145/3058751

25. Welsh, M. The end of programming. *Communications of the ACM*, 66, 1 (2023, January), 34–35.

26. Wing, J.M. *Computational Thinking.* (New York: ACM, 2006); doi:10.1145/1118178.1118215

27. Woodward, J. (chair) Improving mathematical problem solving in grades 4 through 8. *Educators' Practice Guide, NCEE 2012-4055*, (What Works Clearinghouse, 2012). Accessed 2023 January 22.

**Author**

**Lorraine A. Jacques, PhD**

University of Tampa, 401 W. Kennedy Blvd., Tampa, FL 33606

*[email protected]*

**Footnotes**

1. CS Unplugged is a collection of free learning activities that teach Computer Science through engaging games and puzzles that use cards, string, crayons, and lots of running around. See *Current Acronyms* in this issue of *Inroads.*

**Figures**

Figure 1. ChatGPT's code for reversing the digits in an integer (generated 29 Jan. 2023)

Figure 2. A student flowchart representing ChatGPT's code.

Figure 3. ChatGPT's code for performing a Caesar shift on a string (generated 29 Jan. 2023)

Figure 4. Asking ChatGPT to determine if a string is a palindrome (generated 29 Jan. 2023)

Copyright held by author. Publication rights licensed to ACM.

The Digital Library is published by the Association for Computing Machinery. Copyright © 2023 ACM, Inc.

Contents available in PDFView Full Citation and Bibliometrics in the ACM DL.

To comment you must create or log in with your ACM account.

## Comments

There are no comments at this time.