---

Mastering List Manipulation in 8th: The Complete High Scores Guide

Effortlessly manage high scores in 8th by leveraging its powerful list manipulation words. This guide teaches you to find the maximum value using a:max, retrieve the last entry with a:last, and extract the top three scores by combining a:sort, a:rev, and a:slice.

Remember the electric thrill of an arcade? The glowing screen, the clatter of buttons, and that one ultimate goal: getting your initials on the high score list. That simple list was a digital monument to skill and persistence. In the world of programming, managing such a list—finding the top score, seeing the latest entry, or listing the champions—is a fundamental challenge. It’s a perfect test of how well a language handles data.

Many developers find data manipulation, especially with lists or arrays, to be a repetitive or verbose task in some languages. You might feel bogged down by complex loops, temporary variables, and hard-to-read syntax. This is where the elegance of a stack-based language like 8th shines. This guide will walk you through building a high-score manager from the ground up, transforming what seems like a chore into an intuitive, powerful, and surprisingly concise exercise. You will not only solve the problem but also gain a deep appreciation for the 8th way of thinking.

---

What is the High Score Challenge in 8th?

At its core, the high score challenge is a classic data manipulation problem sourced from the exclusive kodikra.com curriculum. The task is to create a set of functions (or "words" in 8th terminology) that can operate on a given list of scores. This list is a simple array of integers, representing the scores achieved by a player over time.

The requirements are specific and practical, mirroring real-world application needs:

• Retrieve the List of Scores: A baseline function that simply returns the list it was given.
• Find the Last Added Score: Isolate and return the most recent score added to the list. This is often useful for displaying a player's latest performance.
• Find the Personal Best: Scan the entire list and identify the single highest score ever achieved.
• List the Top Three Scores: Identify and return a new list containing the three highest scores, sorted from highest to lowest.

This problem is an ideal vehicle for learning fundamental concepts in 8th. It forces you to move beyond simple arithmetic and engage with one of the language's most powerful features: its rich library for array and list manipulation. By solving this, you build a solid foundation for tackling more complex data processing tasks.

---

Why Use 8th for Data Manipulation?

You might wonder why you'd choose a Forth-like, stack-based language like 8th for a task that seems perfectly suited for Python or JavaScript. The answer lies in the 8th philosophy of simplicity, directness, and composition. Instead of writing verbose loops or chaining long method calls, 8th encourages a different style of problem-solving.

Concatenative Power: In 8th, programming feels like assembling a pipeline. You start with data on the stack, and then you apply a series of words, each one transforming the data and leaving the result on the stack for the next word. This is called a concatenative approach. For our high score problem, you can literally read the code as a series of steps: "take the list, sort it, reverse it, then take the top three."

Readability and Brevity: Once you acclimate to the "postfix" notation (e.g., data function instead of function(data)), 8th code becomes remarkably dense and expressive. The logic for finding the top three scores, which might take several lines in other languages, can be a single, elegant line in 8th.

Interactive Development: 8th's REPL (Read-Eval-Print Loop) is a powerful tool for building and testing your logic piece by piece. You can place a list on the stack, apply the a:sort word, and immediately see the result. This interactive feedback loop accelerates development and deepens understanding.

Performance: While being a high-level, dynamic language, 8th is designed for efficiency. Its core operations and built-in words are highly optimized. For tasks like sorting and slicing lists of reasonable size, the performance is more than sufficient and often surprisingly fast due to the simplicity of its underlying virtual machine.

This module is a core part of our 8th Learning Path, designed specifically to highlight these unique strengths of the language.

---

How to Implement the High Score Logic in 8th

Now, let's transition from theory to practice. We will build the solution step-by-step, explaining the purpose of each word and how they chain together to produce the final result. The entire logic will be contained within a single file, which we'll call high-scores.8th.

The Core Data Structure: An Array

In 8th, the primary tool for holding a collection of items is the array, often used interchangeably with the term "list". It's a dynamic, ordered collection of values. For our exercise, the input will always be an array of integers.

\ Example score list
[ 100, 0, 90, 30, 70 ]

This array will be the single item on the stack when our custom words are called.

The Complete Solution: `high-scores.8th`

Here is the full, commented source code for the solution. Each word is defined to expect one item on the stack: the array of scores.

\ high-scores.8th
\ This file contains the solution for the High Scores module
\ from the kodikra.com 8th learning path.

\ --- Word Definitions ---

\ : scores ( a -- a )
\ A simple word to return the list of scores.
\ In practice, this can be seen as an identity function for the list.
: scores ;

\ : last-score ( a -- n )
\ Takes a list of scores and returns the last one added.
\ The a:last word is a built-in that does exactly this.
: last-score a:last ;

\ : personal-best ( a -- n )
\ Takes a list of scores and returns the highest score.
\ The a:max word efficiently finds the maximum value in an array.
: personal-best a:max ;

\ : personal-top-three ( a -- a )
\ Takes a list of scores and returns a new list with the three highest scores,
\ sorted in descending order.
: personal-top-three
  a:sort      \ Sorts the array in ascending order
  a:rev       \ Reverses the sorted array to get descending order
  2 0 a:slice \ Slices the array from index 0 for a length of 3
;

Code Walkthrough: A Deep Dive into the Logic

Let's dissect each custom word to understand how it manipulates the stack and uses 8th's built-in array library.

1. Finding the Last Added Score with last-score

This is the most straightforward task. We need to get the last element from the array.

• The Word: a:last
• What it does: a:last is a built-in word that takes an array from the top of the stack, removes the last element, and pushes that element back onto the stack.

The implementation is a simple mapping of our desired name, last-score, to the built-in word.

Here is an ASCII art diagram illustrating the stack's state before and after the operation:

    Initial Stack
  ┌─────────────────┐
  │ [10, 30, 20, 50]│ ← Top
  └─────────────────┘
           │
           ▼
     Apply `a:last`
           │
           ▼
      Final Stack
  ┌─────────────────┐
  │       50        │ ← Top
  └─────────────────┘

2. Finding the Personal Best with personal-best

This task requires us to find the single largest number in the array. Again, 8th provides a highly optimized word for this.

• The Word: a:max
• What it does: a:max consumes an array from the stack and pushes its single greatest element onto the stack. It works for numbers and can even work for strings (lexicographical comparison).

Our personal-best word is a direct alias for this powerful built-in.

\ Stack transformation for personal-best
\ BEFORE: [ 100, 0, 90, 30, 70 ]
\ AFTER:  100

3. The Main Challenge: Finding the Top Three with personal-top-three

This is where the concatenative nature of 8th truly shines. We need to perform a sequence of operations: sort the scores, arrange them from highest to lowest, and then pick the first three. Our implementation does this in a clean, logical pipeline.

Let's follow the data on the stack through the personal-top-three word:

1. Initial State: The stack starts with our list of scores: [ 40, 100, 70, 90, 30 ].
2. a:sort: This word is applied first. It sorts the array in-place in ascending (smallest to largest) order. The stack now holds: [ 30, 40, 70, 90, 100 ].
3. a:rev: Next, we apply a:rev (reverse). This reverses the elements of the array, turning our ascending list into a descending one. The stack now holds: [ 100, 90, 70, 40, 30 ]. This is exactly what we need—the highest scores are now at the beginning of the list.
4. 2 0 a:slice: This is the final step. The a:slice word is powerful. It expects three arguments on the stack: the array to slice, the starting index, and the length of the slice. However, in 8th, arguments are placed on the stack *before* the word is called. So, we push 2 (the index of the last element of the slice, which is length-1) and 0 (the starting index) *before* calling a:slice. It consumes the array, the start index, and the end index, and pushes a new array containing just that "slice". The stack is left with our final result: [ 100, 90, 70 ].

This entire multi-step process is beautifully illustrated by the following flow diagram:

    ● Start with Score List
    │  e.g., [40, 100, 70, 90, 30]
    ▼
  ┌────────────────┐
  │     a:sort     │  Sorts ascending
  └───────┬────────┘
          │
          ▼
    ● Sorted List
    │  [30, 40, 70, 90, 100]
    ▼
  ┌────────────────┐
  │      a:rev     │  Reverses to descending
  └───────┬────────┘
          │
          ▼
    ● Reversed List
    │  [100, 90, 70, 40, 30]
    ▼
  ┌────────────────┐
  │   2 0 a:slice  │  Takes elements from index 0 to 2
  └───────┬────────┘
          │
          ▼
    ● Final Result
       [100, 90, 70]

Running the Code in the 8th REPL

To test your solution, you can use the interactive 8th REPL. First, save the code above as high-scores.8th. Then, start the REPL and load the file.

$ 8th
> "high-scores.8th" f:load
ok
> [ 100, 0, 90, 30, 70 ] ' personal-top-three call
[100, 90, 70]
ok
> .s
Stack (1):
[100, 90, 70]
> [ 100, 0, 90, 30, 70 ] ' personal-best call
100
ok
> [ 100, 0, 90, 30, 70 ] ' last-score call
70
ok

The command ' personal-top-three call takes the array we just pushed to the stack, finds our word definition, and executes it. The .s command shows the current state of the stack, confirming our result.

---

Alternative Approaches & Performance Considerations

While using the built-in words is almost always the best approach in 8th, it's a valuable learning exercise to consider how you *could* implement this logic manually. This helps you appreciate the efficiency and convenience of the standard library.

Manual Implementation vs. Built-in Words

Let's consider manually finding the personal best without a:max. You would need to iterate through the list, keep track of the highest score seen so far, and update it if you find a larger one. This involves more complex stack management and logic.

Approach	Pros	Cons
Using Built-in Words (a:max, a:sort)	Highly Readable: The intent is immediately clear. Concise: Minimal code to write and maintain. Optimized: The underlying implementation is written in C and is very fast. Less Error-Prone: Relies on well-tested library code.	Abstracts away the underlying algorithm, which might be a downside for academic purposes.
Manual Iteration (e.g., using a:each)	Provides explicit control over every step of the algorithm. Good for learning low-level stack manipulation and control flow.	Verbose: Requires significantly more code. Slower: Interpreter overhead for loops is higher than a native C implementation. Complex Stack Juggling: Managing the loop variable, the current max, and the list itself on the stack can be tricky. Easy to Introduce Bugs: More code means more opportunities for errors.

The key takeaway is to always prefer the standard library's words unless you have a very specific, custom requirement that they cannot meet. The designers of 8th included them for a reason: they are robust, fast, and idiomatic.

---

Where Can You Apply These List Manipulation Skills?

Mastering list manipulation in 8th opens doors to a wide variety of applications beyond simple game scores. The patterns you've learned here—sorting, filtering, and slicing—are the bedrock of data processing in any domain.

• Web Development: Building API endpoints that return sorted and paginated data from a database query. For example, showing the "Top 10 most recent comments" on a blog post.
• Data Analysis: Parsing log files or CSV data, finding outlier values (max/min), and calculating statistical measures like medians (which also requires sorting).
• Financial Technology: Processing lists of stock transactions to find the highest daily price, the last traded price, or the top N most volatile stocks.
• Embedded Systems & IoT: Analyzing streams of sensor data to find peak readings, filter out noise, or identify the most recent events from a device.
• DevOps & System Administration: Writing scripts that parse command output (e.g., a list of running processes) to sort them by memory usage and identify the top consumers.

The fundamental skill is recognizing that your data can be modeled as a list and that a sequence of transformations can get you to your desired result. For a deeper dive into the language itself, check out our complete 8th language guide.

---

Frequently Asked Questions (FAQ)

What exactly is a "word" in 8th?

In 8th, a "word" is the fundamental unit of execution, equivalent to a function, method, or subroutine in other languages. Words are separated by whitespace. Everything in 8th is a word, from mathematical operators like + to control flow structures and custom definitions created with :.

Why is 8th stack-based? What does that mean for my code?

8th is stack-based, meaning most operations communicate by taking their arguments from a shared data structure called the stack and placing their results back onto it. This eliminates the need for most local variables and named parameters. It encourages a "point-free" or "tacit" style of programming where you define functions by composing other functions, leading to very concise and reusable code.

How efficient is a:sort? What algorithm does it use?

The built-in a:sort word is highly efficient because it's implemented in the language's core, typically in C. While the specific algorithm is an implementation detail, it's safe to assume it uses a modern, high-performance sorting algorithm like Timsort or a variation of Quicksort, providing average-case performance of O(n log n).

How is an array different from a list in 8th?

In the context of 8th, the terms "array" and "list" are often used interchangeably. They both refer to the primary collection type, created with [ ... ] syntax. It is a dynamic, ordered collection of heterogeneous elements.

Can I find the top N scores instead of just the top 3?

Absolutely. The number 2 in our 2 0 a:slice call is what determines the number of elements. Since slicing takes a start and end index, to get N items, you would use (N-1) 0 a:slice. For example, to get the top 5, you would use 4 0 a:slice.

What happens if the list has fewer than three scores when I call personal-top-three?

The 8th array words handle this gracefully. If you call a:slice with a range that exceeds the array's bounds, it will simply return all the elements it can. For example, if the list is [ 100, 80 ], after sorting and reversing, 2 0 a:slice will correctly and safely return the entire list [ 100, 80 ] without causing an error.

Why do we need to reverse the list after sorting?

The a:sort word, by convention in 8th and many other languages, sorts in ascending order (from smallest to largest). To get the "top" or "highest" scores, we need them in descending order (largest to smallest). The quickest way to achieve this is to perform an ascending sort and then simply reverse the resulting list with a:rev.

---

Conclusion: Your Foundation in Data Manipulation

Congratulations! You have successfully built a fully functional high-score manager in 8th. More importantly, you've gained hands-on experience with the core of what makes the language so powerful for data processing. You've seen how simple, composable words like a:last, a:max, a:sort, a:rev, and a:slice can be chained together in an intuitive pipeline to solve a complex problem with minimal code.

This exercise from the kodikra.com learning path is more than just about games; it's a foundational lesson in thinking about data as a stream that you can transform step-by-step. This paradigm is incredibly powerful and will serve you well as you tackle more advanced challenges in any programming domain. The skills you've honed here are directly applicable to a vast array of real-world problems.

Technology Disclaimer: The code and concepts discussed in this article are based on recent stable versions of the 8th programming language. The core array manipulation library is stable, but always consult the official documentation for the specific version you are using for the most up-to-date information.

---

Published by Kodikra — Your trusted 8th learning resource.