Bill MacKenty

Automation Has Made Programming Less Fun.

I still remember the flicker of excitement I felt when I wrote my first line of code at 14...

The screen blinked back at me, a silent acknowledgment of the journey I was embarking upon. Over the past 41 years, coding has been more than just a profession; it's been a passion fueled by curiosity, creativity, and the thrill of solving complex problems. But recently, I had an experience that made me question the evolving landscape of programming and its impact on the joy it once brought me.

A few weeks ago, I decided to create a simple ASCII-art 4X space game—a project that, in the past, would have been a delightful challenge filled with hours of brainstorming, debugging, and incremental victories. This time, however, I turned to a Large Language Model (LLM) to assist me. In just about two hours, the game was complete. No hurdles, no late-night problem-solving sessions, no trial-and-error. And yet, instead of feeling accomplished, I was... bored.

Coding has always been akin to solving a intricate puzzle. Each bug fixed and each function optimized brings a sense of achievement that's hard to replicate. The process demands patience, logical thinking, and creativity. It's not just about the end product; it's about the journey—the countless trials and errors that lead to the final result.

When an LLM can generate code in a fraction of the time, it strips away the challenges that make coding rewarding. The automation of problem-solving turns an engaging process into a mechanical one. The excitement of unraveling a complex issue diminishes when the solution is handed to you on a silver platter.

As an educator, I see the same patterns emerging among my students who are learning to code. The allure of quick solutions is tempting, but it deprives them of the fundamental experiences that build proficiency and confidence. Struggling with code isn't a setback; it's a crucial part of the learning curve. It's through debugging and iterative problem-solving that students develop a deeper understanding of programming concepts.

When students rely too heavily on AI-generated code, they miss out on the opportunity to think critically and develop their problem-solving skills. The "eureka" moments that come after hours of hard work are invaluable. They not only reinforce learning but also build resilience and a growth mindset.

This isn't to say that LLMs and AI tools have no place in programming—they undoubtedly increase efficiency and can handle repetitive tasks with ease. However, it's essential to strike a balance. For seasoned programmers like myself, perhaps it's about using these tools to handle mundane aspects while reserving the more challenging problems for manual coding. For students, it might mean using AI as a learning aid rather than a crutch.

Coding is changing rapidly with the advent of AI and automation. While these tools offer incredible benefits, they also pose questions about the future of programming as a fulfilling craft. For those of us who find joy in the challenges of coding, it's important to remember why we started in the first place. And for the new generation of coders, embracing the hard work and the hurdles isn't just beneficial—it's essential.

The next time you sit down to code, consider taking the longer path. Embrace the difficulties, relish in the trial-and-error, and remember that sometimes, the struggle is where the real fun lies.

Exciting changes in IB computer science

A new IB computer science curriculum is being released! Read more about it here....

The Overview is here: https://www.ibo.org/university-admission/latest-curriculum-updates/computer-science-updates/

The subject brief is here: https://www.ibo.org/globalassets/new-structure/university-admission/pdfs/dp_comp_sci_subjectbrief_en.pdf (local copy here: dp_comp_sci_subjectbrief_en.pdf)

A lot of writing lately

I've been doing a ton of writing for an interesting project. I can't wait to share it with you. I've also been developing setting for a far-future science fiction...

So. Much. Writing. I can't wait to share a project I'm working on. It should be ready by next February, and I am very hopeful it will be impactful and important.

In addition to mega-secret project alpha, I've also been developing a far-future science fiction setting lately. Most of the content is here. The idea is to create a universe in the year 7019 - far enough in the future to think and imagine and play with ideas related to who we might become. I'm folding in a space trading game I started working on a while ago (link here) but I haven't started to assign values or abstracted the ideas yet. I am hoping for a book, a computer role playing game, and a table top role playing game.

I start with vague ideas about who we are and cycle out to think about 100 years, 300 years, 1000 years. It's a really fun exercise. I have been thinking about history, and how we have changed (and haven't changed). It's helpful to extrapolate our past into our future.

Of course I have species, planets, events, factions, etc... What I really want to capture is the variety within a setting. It's challenging because the broader the scope, that harder it is to understand what that scope means. I think most science fiction is rather one dimensional - star trek focuses tightly on a bridge and a top-down command structure. Although star trek references a big universe, it only portrays a narrow window of it most of the time. My favorite types of stories are when there is a switching between micro and macro. Tom Clancy's book, Red Storm Rising did this beautifully.

Lots more to say, but I'm thinking a lot about the future these days.

The future of high school computing

Large language models like ChatGPT mandate we change the way we approach high school computing.

This article will discuss the importance of differentiation between software engineering and computer science in secondary (high school) educational settings and the impact of large language models on the former. Without correct understanding of computing, we can't fully appreciate how LLM's change it.

In the 2020 Computing Curricula recommendation, the Association for Computing Machinery (ACM) states that within the domain of computing, there are five primary disciplines. The reason it is important to understand this is because while there are some shared characteristics between these disciplines, they are different enough to be taught as distinct disciplines.

1. Computer Engineering (CE)
2. Computer Science (CS)
3. Information Systems (IS)
4. Information Technology (IT)
5. Software Engineering (SE)

To acquire a deeper comprehension and appreciation of these disciplines' distinctions and interconnections, please refer to the following documents:

1. Overview of Computing Fields
2. Field Characteristics
3. ACM 2020 Computing Curricula Recommendations

For some more serious approachesThere is a lot of noise and hype around AI in education - I tried to find respected institutional research to help frame LLM's within education. to AI in education research, please refer to the articles below:

1. Artificial Intelligence and the Future of Teaching and Learning
2. Artificial intelligence and the Futures of Learning
3. The Position of Artificial Intelligence in the Future of Education: An Overview

High schools (and even some universities) often blur the lines between software engineering and computer science, using these terms interchangeably and without recognizing their essential distinctions When your students are applying to university please - I'm begging you - insist they read the actual courses they will be taking. . This conflation creates an ambiguous academic journey for students entering the computing field. While there is some overlap between the disciplines, clearly defined tracks are important in guiding students along the right trajectory.

In numerous educational institutions, students are exposed to programming (akin to software engineering), robotics (related to computer engineering), and occasionally resource management and abstract data structures (pertaining to computer science). Often, the overarching terms used for this education are "computer science", "technology" or "computers".

To make the distinction clearer and prepare students for the evolving world of computing, it is essential to design two distinct tracks within high school computing:

Track 1: Software Engineering

The significance of this track stems from the transformative impact large language models (LLMs) like ChatGPT have on problem-solving through programming. Students should be taught the fundamental coding concepts such as variables, control structures, and data structures. However, they must also learn to harness the power of LLMs in solving problems. By integrating LLMs, students can explore innovative ways to create solutions. Essentially, software engineering should focus on basic programming, computational thinking, and the astute utilization of LLMs. I include tools like co-pilot, tabnine, and YouCompleteMe, which use LLM-like technology to vastly improve programming output.

Track 2: Computer Science

The second track should concentrate on the foundational aspects of computer science. This encompasses theoretical data structures, advanced mathematics, and computing theories. The core areas of study within Computer Science include artificial intelligence, computer systems and networks, security, database systems, human-computer interaction, vision and graphics, numerical analysis, programming languages, software engineering, bioinformatics, and the theory of computing.

Conclusion

With the advent of LLMs, it is imperative for the education system to adapt and prepare students for the dynamic computing landscape. While LLMs present extensive possibilities for problem-solving, it is also crucial to nurture the next generation of computer scientists who will forge cutting-edge tools. Equipping students with the right skills and knowledge will be an important differentiator for students entering college and universities.

Entity-Component-System 〈ECS〉

Different than oop? Read on...

I've learned about the Entity-Component-System (ECS)

Obligatory chatGPT / wikipedia definition: ECS is a pattern for game development that provides a way to organize and structure game logic. It is a way of designing games that separates the data (components) and behavior (systems) of entities.

In an ECS, entities are objects in the game, such as characters or enemies. Components are data structures that define the properties and attributes of an entity, such as its position, health, or sprite. Systems are responsible for updating and manipulating the components of entities.

The separation of data and behavior in an ECS allows for more flexible and modular game development, as it is easier to add or change components and systems without affecting the rest of the code. It also allows for better performance and scalability, as systems can be optimized for processing specific types of components.

Overall, the ECS pattern provides a clean and efficient way to structure game logic, making it a popular choice for game development, especially for large and complex games.

Entity Component System (ECS) is a software architectural pattern mostly used in video game development for the representation of game world objects. An ECS comprises entities composed from components of data, with systems which operate on entities' components.

ECS follows the principle of composition over inheritance, meaning that every entity is defined not by a type hierarchy, but by the components that are associated with it. Systems act globally over all entities which have the required components.

Entity: An entity represents a general-purpose object. In a game engine context, for example, every coarse game object is represented as an entity. Usually, it only consists of a unique id. Implementations typically use a plain integer for this.

Component: A component labels an entity as possessing a particular aspect, and holds the data needed to model that aspect. For example, every game object that can take damage might have a Health component associated with its entity. Implementations typically use structs, classes, or associative arrays.

System: A system is a process which acts on all entities with the desired components. For example, a physics system may query for entities having mass, velocity and position components, and iterate over the results doing physics calculations on the sets of components for each entity.

The behavior of an entity can be changed at runtime by systems that add, remove or modify components. This eliminates the ambiguity problems of deep and wide inheritance hierarchies often found in Object Oriented Programming techniques that are difficult to understand, maintain, and extend. Common ECS approaches are highly compatible with, and are often combined with, data-oriented design techniques. Data for all instances of a component are commonly stored together in physical memory, enabling efficient memory access for systems which operate over many entities.

Need a procedurally generated country?

Every once in a while one of my students hits the ball out of the park...

Not much sure how much better you could do than this: 

https://github.com/bmackenty/s...

Current thinking about chatGPT

How should a high school computing teacher use chatGPT?

1. Ensure students understand the technical boundaries
2. Teach students to ask precise questions (with follow-up questions if necessary)
3. Teach students to evaluate answers
   
   
4. As teachers we should encourage students to ask all questions via a text interface (so we can capture questions) and fine-tune the model to reply. The goal is to have a "reasonably good" assistant that can support students as they work through content required by the syllabus. The input for questions should be textual / copy-paste / and spoken word. 

Writing a report card comment generator

Saving time whilst providing accurate information about a students progress isn't easy, but certainly worth it...

I wrote a report card generator. The GitHub repo is here. It's version 0.1 but I used it and it saved me some time. There are many things to add and edit, but perfection is the enemy of good (I'm not sure I got that quote right). 

I'm hoping to eventually offer it as a web service for students and parents to use so we can co-create a story about student learning. 

Displaying courses in grid format on moodle homepage

After much searching I was lucky to get a helpful reply from a friendly moodler. Read on...

On the front page of moodle when using the boost theme, there is a linear list of courses. If you want a grid of courses, you can use the suggestion from here, a plugin named filter codes. I tested this on moodle version 4.1 and it works perfectly. 

chatGPT part 3: how do I know you know?

Out-of-school coding assignments are no longer as important as being able to understand the code. The return of oral exams?

As a computing teacher I use standard written assessments with my students. Questions include different assessment objectives such as "state", "describe" and "explain". I also use small code problems where students must solve a problem and write an answer in pseudocode. There is an internal assessment that students write; worth 25% of their final grade students must solve a problem for a real client. This is mostly independent, and a place where students could use outside tutors to solve a problem. 

For any work outside of class, I will add oral component to the assessment.

According to chatGPT, 

Some key steps for structuring an oral exam for computer science include:

1. Determine the goals and objectives of the exam: The first step in structuring an oral exam for computer science is to clearly define the goals and objectives of the exam. This will help to ensure that the exam is focused and that it effectively evaluates the student's knowledge and understanding of the material.
2. Identify the key topics and concepts to be covered: Once you have determined the goals of the exam, you can identify the key topics and concepts that will be covered. This could include specific programming languages, algorithms, data structures, or key theories or ideas in computer science.
3. Create a structured format for the exam: To ensure that the exam is well-organized and focused, it's important to create a structured format for the exam. This could involve dividing the exam into different sections, each focused on a specific topic or concept, or using a specific format (e.g. Q&A, presentation, problem-solving) to evaluate the student's knowledge.
4. Develop a list of questions: The next step is to develop a list of questions that will be used during the exam. These should be focused on the key topics and concepts covered in the exam, and should be designed to evaluate the student's knowledge and understanding of the material.
5. Plan for student evaluation and feedback: Finally, it's important to plan for student evaluation and feedback. This could involve using a grading rubric to evaluate the student's performance, providing written or verbal feedback to the student, or allowing the student to ask questions or provide feedback on their own performance.

Overall, the best way to structure an oral exam for computer science is to carefully plan and organize the exam, focusing on the goals and objectives of the exam and the key topics and concepts that will be covered. By following these steps, you can create an effective oral exam that effectively evaluates the student's knowledge and understanding of the material.

chatGPT: teaching computing

What is the answer when asking an AI to please describe the most effective techniques and methods of teaching high school computer science?

ChatGPT answers: 

There is no one-size-fits-all answer to this question, as the most effective teaching methods will depend on the specific goals and objectives of your course, the abilities and needs of your students, and the resources and materials available to you. However, there are some general principles and best practices that can help you create an effective and engaging learning environment for your students.

First, it's important to create a clear and organized syllabus that outlines the goals and objectives of your course, as well as the specific topics and concepts that your students will be learning. This will help your students understand what they can expect from the course and how they can prepare for success.

Next, it's important to use a variety of teaching methods to engage and motivate your students. This can include interactive lectures, discussions, hands-on activities, and group work. Using a variety of teaching methods can help keep your students engaged and interested in the material, and can also help students with different learning styles to succeed.

It's also important to incorporate real-world examples and applications into your teaching, to help students understand how the concepts and skills they are learning can be applied in the real world. This can help make the material more relevant and meaningful to your students, and can also help to motivate and inspire them.

Finally, it's important to provide regular feedback and support to your students, to help them understand where they are succeeding and where they may need to improve. This can include providing individualized feedback on assignments and exams, as well as offering extra help and support outside of class. Providing this kind of support can help your students feel confident and supported in their learning, which can in turn help them to succeed in your course.

Overall, the most effective techniques and methods for teaching high school computer science will depend on your specific goals and objectives, as well as the abilities and needs of your students. By using a variety of teaching methods, incorporating real-world examples and applications, and providing regular feedback and support, you can create an effective and engaging learning environment for your students.

Bill comments: 

Yea, about that.

Procedural generation as a teaching approach

In computing, procedural generation is a method of creating data algorithmically as opposed to manually, typically through a combination of human-generated assets and algorithms coupled with computer-generated randomness and processing power (ref).

The amazing thing about procedural generation is that infinite unique possibilities can be created with little work from humans (ref). I've been interested in procedural for a few years, and would encourage you to take a peek at the following resources to learn about procedural generation: 

1. This is an excellent introductory article
2.  Dwarf Fortress (an incredibly complex game that is largely procedurally generated)
3.  No Man's Sky (this a wiki article describing how procedural generation works)

What is cool about procedural generation is how easy it is to start with procedural generation.  In the example code below, we can get the following output: 

1. Discovered in the small village of Tr'lor
2. Hatched in the ocean of Greenest
3. Born in the small village of Mirkwood

# procedural generator to write a brief history
import random

origin_1 = ["Born", "Hatched", "Invoked", "Discovered"]
origin_2 = ["in the land of", "in the wilds of", "in the forest of", "in the ocean of", "in the small village of", "in the modest hamlet of"]
origin_3 = ["Tr'lor", "Kor'mer", "Kobiyashi", "Greenest", "Mordora", "Gondor'e", "Rivendell", "Mirkwood"]

story_part_1 = random.choice (origin_1) + " " + random.choice(origin_2) + " " + random.choice(origin_3)
print(story_part_1)

I have some students working at high levels of complexity and other students working with more basic levels, as seen above. But for all of them, this is a fun approach to deconstructing a complex system, identifying the patterns within the system, and introducing the correct randomness to the system to make it unique. 

Procedural generation gets us close to modeling and simulation where a student must understand a system in order to create a model of it. In my opinion, modeling and simulation is close to the the very best learning we can get. 

Procedural generation goes into the stratosphere when students apply machine learning to highly complex systems. 

The design cycle works

Considered and deliberate approach to design leads to high quality solutions. The obverse is also true.

My 9th and 10 grade (ages 15 and 16) students are working the design cycle as they solve a problem through programming. The problems are all unique, and fit the student's skill / capacity window.  An example of some the projects are below:

The students have begun to really think and understand their problem. As they dig into the problems, I note they are changing their success criteria and more carefully adding features based on research into solutions. This process - of inquiry into a problem and understanding the problem deeply - reinforces the power of design. 

In education, we talk about transfer learning, where students can transfer learning to novel scenario or situation. A key question I like to ask is:

What do I want my students to know / be able to do in 5 years, 10 years

This kind of approach to solving problems is extraordinarily powerful, and a good thing™ to have in schools. Students who do not attend to this process generally do not have high quality solutions.

A wonderful way to learn software engineering

Authentic student projects; choice, choice, choice.

I teach two different courses primarily concerned with software engineering; 

1. Designing Solutions Through Programming
2. Solving Complex Problems Through Programming

In both courses I offer students a choice about what problem they want to solve. As long as the problem isn't too easy or too difficult I approve the project. This creates agency which well-serves my students. I find I get increased engagement, excitement, a sense that students are working a “real” solution which matters. From AMLE:

Student agency relates to ways that students can intentionally influence their own circumstances (Bandura, 2006). Agency can also be defined as a “student’s desire, ability, and power to determine their own course of action” (Vaughn, 2018, p. 63). Agency depends on “intentionality and forethought to derive a course of action and adjust course as needed to reflect one’s identity, competencies, knowledge and skills, mindsets, and values” (Nagaoka et al., 2015, p. 6). These elements suggest areas within which teachers can support student agency: through curriculum, instruction, assessment, and the ways in which they structure learning opportunities (source).

This is though, more difficult to manage. I like to use templates that students can alter and modify to build solutions. We deliberately and carefully learn about each part of a template so students can understand the code, and not just copy-and-paste chunks without understanding how it works. 

I plan on writing more about this, but this overall structure, where we teach students how to code, walk them through a template, and then build an authentic application allows them to transfer their learning to build applications and then “think software engineering”. 

How do we measure students computational thinking?

This PDF answers the question.

Good stuff.

Building a computer science wiki

I've been very busy online lately, just not here 😊 Please do take a look at my computer science wiki. I'm building it for my high school, middle school, and IB students. Once it is filled-out enough, I will probably ask the internet for some help to add to it. Please enjoy, and check out the list of recent changes.

Six rules for asking questions in computer science

The more complex code is, the longer it takes to understand and debug. If it is poorly written code, a multiplier is added to the time required to read it. I have worked with my students to build a "must do before asking questions" list in computer science. 

1. Google your question 
2. Re-read your code (or function). It can be helpful to read this backwards 
3. Use debugging tools 
4. Ask the person next to you 
5. Read error messages! 
6. If you have to ask a teacher for help, make sure you ask a very specific question about a very specific topic

 Great questions get great answers. Bad questions get, well, not-great answers.

Increasing complexity == increasing time to read

I need some advice about a common question: "can you look at my code really quickly"?

I am starting to work on increasingly sophisticated programs with my students. My students ask me to help them diagnose a problem, suggest alternatives, or figure out what is broken in their code.

My problem is reading their code takes time, thinking about what they are doing takes time, and suggesting a good alternative takes time. This isn't something I can do in 30 seconds.

How do you manage student requests for support and assistance when their code is very complex and requires more than 5 or 10 minutes to read? 

Object construction

connecting new learning to learning in the past

I'm continuing my learning in JavaScript. 

Today, I reviewed and refreshed my understanding about objects, and object instantiation. 

I have always clearly understood creating, modifying, and deleting objects and their attributes. Today, though, I learned a new term: object literal notation and object constructor. 

In my PHP work, I've seen "constructor" term, and truthfully, never fully understood it. After review and practice today, I see how it works. 

It's funny, I always "hook" my new learning onto something I learned in the past. In this case, my work building text-based games was instrumental in my understanding of objects. @create foo; @set foo=thing/value, etc... 

I have forgotten how much I enjoy /just coding/ and hacking. It is a real pleasure.

Computational thinking, Minecraft and a 5 year old?

According to wikipedia, the primary characteristics of computational thinking are decomposition, data representation, generalization/abstraction, and algorithms. 

Specifically, computational thinking is a problem solving framework where: Analyzing and logically organizing data Data modeling, data abstractions, and simulations Formulating problems such that computers may assist Identifying, testing, and implementing possible solutions Automating solutions via algorithmic thinking Generalizing and applying this process to other problems ...are used to approach problems. How then, can we use minecraft to help a 5 year old (my daughter) start to understand these concepts? 

I think the best way is to build a trap for monsters. Firstly, she would have to use cause-and-effect thinking. She would also need to break the trap into it's different parts. She would need to design a trap, and test it. In broad strokes, we will approach like this: 

1. Define the problem (zombies, skeltons, and creepers)
2. Understand the component parts of a trap
3. With the component parts, she will design a trap
4. She will test the trap
5. She will generalize ways the trap can be used in other situations 

Ok, I'll be honest, this isn't a good example of computational thinking. The classic decomposition, data representation, generalization/abstraction, and algorithms are not really present. But this would get us on a good road, wouldn't it? What do you think?

Yea! I learned something that I actually used!

I'm refershing my javascript skillset by going through a code academy course. Laborious, but helpful. Today, while supporting a co-worker on a powerschool customization, we were looking at a problem. I realized a variable was declared within a function but wasn't scoped to be used outside of the function (globally). Once fixed, we were running strong.

I just studied variable scope in my refresher course, and I'm grateful I did! As always, the wonderful stack exchange has a well-written piece about variable scope within javascript.

I suppose it is mildly depressing that I am excited about learning something that I can actually use. That must mean I normally learn things that are useless.

What is computational thinking in K-12 space?

Any look at computer science in the K-12 space leads inexorably towards the notion of computational thinking. My elevator speech on computational thinking is "thinking to computer". But there are many other, far better sources we can find below:

From Google comes this excellent answer

Computational thinking (CT) involves a set of problem-solving skills and techniques that software engineers use to write programs that underlie the computer applications you use such as search, email, and maps. Here are specific techniques.

Decomposition: Breaking a task or problem into steps or parts.
Pattern Recognition: Make predictions and models to test.
Pattern Generalization and Abstraction: Discover the laws, or principles that cause these patterns.
Algorithm Design: Develop the instructions to solve similar problems and repeat the process.


From the CSTA:

“CT is an approach to solving problems in a way that can be implemented with a computer. Students become not merely tool users but tool builders. They use a set of concepts, such as abstraction, recursion, and iteration, to process and analyze data, and to create real and virtual artifacts. CT is a problem-solving methodology that can be automated and transferred and applied across subjects. The power of computational thinking is that it applies to every other type of reasoning. It enables all kinds of things to get done: quantum physics, advanced biology, human–computer systems, development of useful computational tools.”

Computational thinking is thus a problem-solving methodology that can interweave computer science with all disciplines, providing a distinctive means of analyzing and developing solutions to problems that can be solved computationally. With its focus on abstraction, automation, and analysis, computational thinking is a core element of the broader discipline of computer science and for that reason it is interwoven through these computer science standards at all levels of K–12 learning Page 9 of the CSTA K-12 computer science standards.

From Jeannette Wing, regarding as the originator of computational thinking:

Computational thinking is a fundamental skill for everyone, not just for computer scientists. To reading, writing, and arithmetic, we should add computational thinking to every child’s analytical ability. Just as the printing press facilitated the spread of the three Rs, what is appropriately incestuous about this vision is that computing and computers facilitate the spread of computational thinking. Computational thinking involves solving problems, designing systems, and understanding human behavior, by drawing on the concepts fundamental to computer science.

Computational thinking includes a range of mental tools that reflect the breadth of the field of computer science.

What is computer science in a K-12 school?

Computer science isn’t learning to use excel. Computer science isn’t about understanding system administration and packet shaping. It’s not about using simulations to better understand biology. 

I think K-12 schools can get confused about the difference between computer science, information technology, and educational technology. They are distinct. 

Computer science is the scientific and practical approach to computation and its applications. It is the systematic study of the feasibility, structure, expression, and mechanization of the methodical procedures (or algorithms) that underlie the acquisition, representation, processing, storage, communication of, and access to information, whether such information is encoded as bits in a computer memory or transcribed in genes and protein structures in a biological cell An alternate, more succinct definition of computer science is the study of automating algorithmic processes that scale.

 A computer scientist specializes in the theory of computation and the design of computational systems source here. There are many reasons K-12 schools don’t “do” computer science well. I suspect one of the larger reasons is the confusion about simple definition. I've seen "computer class" as a catch-all. 

From Running on Empty comes an excellent description of why computer science is difficult to define and implement in K-12 schools: Consistent with efforts to improve “technology literacy,” states are focused almost exclusively on skill-based aspects of computing (such as using a computer in other learning activities) and have few standards on the conceptual aspects of computer science that lay the foundation for innovation and deeper study in the field (for example, develop an understanding of an algorithm). 

As I learn and explore computer science in K-12 space, I would be curious to hear your thoughts about computer science in K-12.