Forem: Refaktor

When if is just a function

Refaktor — Thu, 23 Oct 2025 10:31:39 +0000

In Python, when you write if x > 5: print("big"), you're using special syntax baked into the language. You can't change how if works. You can't compose it, pipe it, or partially apply it. You can't pass if as an argument to another function.

But what if you could? What if if, for, while and even fn and var were just regular functions?

In languages like REBOL, Red and Rye they are.

Three Reasons This Matters

Consistency. Most languages treat control structures as special forms, exceptions to the normal rules. In languages like Rye and REBOL, they're ordinary functions that follow the same patterns as everything else.

Flexibility. Functions can be composed, passed around, and combined. When control structures are functions, you inherit all those capabilities.

Extensibility. If if and for are just functions, you can create your own specialized versions for specific purposes. No part of the language remains off-limits.

Let's see what this looks like in practice.

Looking at If

Here's a conditional in Python:

temperature = 36

# We can evaluate and print an expression
print(temperature > 30)
# prints: True

# We can't really print or evaluate a block of code
# except if we turn it back to string

# Standard conditional - special syntax
if temperature > 30:
    print("It's hot!")
# prints: It's hot!

Compare this to Rye:

temperature: 36

; Evaluates expression and prints the result
print temperature > 30
; prints: true

; In Rye, blocks are data - we can print them
print { print "It's hot!" }
; prints: print "It's hot!"

; The 'do' function evaluates a block of Rye values / code
do { print "It's hot!" }
; prints: It's hot!

; And here's the conditional - also just a function
if temperature > 30 {
    print "It's hot!"
}
; prints: It's hot!

Look at that last if statement. It's not special syntax it's a function call. While functions print and do take one argument, if function takes two arguments:

A condition that evaluates to true or false
A block of code to run if the condition is true

You might wonder: "Won't the block execute immediately when passed as an argument?" Here's the key insight: in Rye, code blocks { ... } are values. They don't evaluate until you explicitly tell them to. The if function receives the block as data and decides whether to evaluate it based on the condition.

When code is data, control flow doesn't need to be special.

Single pattern

In Python, every language feature has its own syntax:

# Conditionals - keywords and colons
if x == 5: 
    print("five")

# Loop
for i in range(10): 
    print(i)

# Iteration
for item in ["milk", "bread", "pickles"]: 
    print(item)

# Functions - def keyword, parentheses, colons, indentation
def add(a, b): 
    return a + b

In Rye, one pattern applies everywhere:

; Conditionals - function taking a boolean and a block
if x = 5 { print "five" }

; Counting loop - function taking an integer and a block
loop 10 { .print }

; Iteration - function taking a collection and a block
for { "milk" "bread" "pickles" } { .print }

; Functions - function taking argument list and body block
add: fn { a b } { a + b }

Every construct follows the same shape: a name, followed by arguments, some of which happen to be blocks of code.

There's no longer a meaningful distinction between "language features" and "library functions."

Consistency & Flexibility

In Python, if and for are statements, not values. But in Rye they are functions, and first of all we can compose functions.

loop either temperature > 32 { 3 } { 1 } { prns "Hot!" }
; Prints: Hot! Hot! Hot!

; We can use optional parenthesis to better show the evaluation order (similar to lisp-s)
( loop ( either ( temperature > 32 ) { 3 } { 1 } ) { prns "Hot!" } )
; Prints: Hot! Hot! Hot!

prns prints a value with a space (no newline)

In Python when using the if statement, this would take multiple lines and a variable mutation:

repeats = 1
if temperature > 32:
    repeats = 3

for _ in range(repeats):
    print("Hot!", end='')
# Prints: Hot! Hot! Hot!

Luckily, python has another special syntax in which if keyword creates an expression:

for _ in range(3 if temperature > 31 else 1):
    print("Hot!", end='')
# Prints: Hot! Hot! Hot!

While special syntax is usualy cemented in place, there are multiple ways to provide arguments to function calls.

hot-code: { print "Hot!" }
is-hot: temperature > 30

if is-hot hot-code
; prints Hot!

loop 2 hot-code
; Prints: Hot!
;         Hot!

Piping Into Control Flow

Functions in Rye can accept a first (or second) argument from the left, so the same applies to "flow control"-like functions of course.
Read more about this in Meet Rye.

; Pipe a condition into if
temperature > 30 |if { print "Hot!" }
; Prints: Hot!

3 .loop { .prns }
; Prints: 0 1 2

; Pipe a collection into for
{ "Hot" "Pockets" } |for { .print }
; Prints: Hot
;         Pockets

In Python, you can't pipe into if or for because they're not values, they're syntax.

Applying functions

In Rye we can apply functions to it's arguments.

apply ?concat { "Bob" "Odenkirk" }

woof: { print "woof" }
meov: { print "meov" }

animals: [ [ false woof ] [ true meov ] ]

for animals { .apply* ?if }
; Prints: meov

?word - is a get-word, it doesn't evaluate a function bound to the word but returns it
word* - star at the end of the word causes function to take second argument from the left, not the first one

Partial Application

In Rye we can also partially apply functions.

add-five: partial ?_+ [ _ 5 ]

add-five 10
; returns 15

three-times: partial ?loop [ 3 _ ]

; Use it like any other function
three-times { prns "Hey!" }
; Hey! Hey! Hey!

We've created a custom "control structure" three-times by partially applying a built-in loop.

Higher-Order Control Flow

We can pass function as arguments to other functions.

Here we create a function that takes a function and reates the same function that prints it's arguments.

verbosify\2: fn { fnc } {
    closure { a b } {
    probe a 
        probe b
        fnc a b
    }
}

myconcat: verbosify\2 ?concat
myconcat "AAA" "BBB"
; Prints:
;  [String: AAA]
;  [String: BBB]
; Returns:
;  AAABBB

myif: verbosify\2 ?if
myif temperature < 30 { print "cold!" }
; Prints:
;  [Boolean: false]
;  [Block: ^[Word: print] [String: cold!] ]

Extensibility

Since control flow is just functions, you can write your own control structures indistinguishable from built-ins.

Unless and Until

; Want the opposite of if?
unless: fn { condition block } {
    if not condition block
}

unless tired { 
    print "Keep working!" 
}

; Need an until loop?
until: fn { condition block } {
    loop {
        r:: do block
        if do condition { return r }
    }
}

count:: 0
until { count > 5 } {
    print count
    count:: inc count
}

Unlimited control flow functions

When you accept this you see that there is no hard border of hard limit to what control strucutre like function you should have. You load them on library level
and specific libraries can provide new ones or offer you functionality in shape that would usually be reserved to special forms.

Part of the base functions, but could be considered special


switch password {
    "sesame" { "Opening ..." }
    "123456" { "Self destructing!" }
}

; I'l admit, I added cases control-function just for the fizz-buzz 
; because I could :P

for range 1 100 { :n
    cases " " {
        { n .multiple-of 3 } { "Fizz" }
        { n .multiple-of 5 } { + "Buzz" }
        _ { n }
    } |prns
}

; outputs: 1 2 Fizz 4 Buzz Fizz 7 8 Fizz Buzz 11 Fizz 13 14 FizzBuzz 16 ...

Higher order functions map filter reduce in Rye also function just like control structures accepting direct code blocks.

They can also accept functions so you can also use them as classic HOF-s.


{ "anne" "bob" "alan" } 
|filter { .start-with "a" }
|map { uppercase } :names
|for { .print }

names .reduce 'acc { .concat acc }

; classic HOF patterns also work
{ 1 2 3 } .map fn { x } { x + 1 }

Even external libraries can have their own functions that utilize blocks of code directly.

For example OpenAI library has a Chat\stream function that accepts a block of
code into which it injects a part of string for each stream event, similar to for loop.

openai Read %.token
|Chat\stream "A joke of the day?" { .prn }

prn - prints a string without adding a newline or space at the end

The Trade-offs

Performance

Python can optimize special forms at compile time. In Rye, if is a function call with some runtime overhead.

Tooling

IDEs know what Python's if, for, def are and can provide specialized support. When everything is a function, you are not limited to a few keywords.

On the other hand

With langauge like Python you have to optimize and provide tools for every special syntax and construct separately.

In Rye, you "just" have to make function calls (builtin function and Rye functions) as fast as possible. And
builtins and functions are self-documenting so if you do make good tools for them you could solve all tooling problems at once.

Interested in learning more? Check out Rye, REBOL or Red to see these ideas in action.

And follow our Github Repo.

Updates after publishing

20.Okt.2025 - Front page of HN produced a lot of interesting comments about this and adjacent themes: hn comments

20.Okt.2025 - Front page of Lobsters also: lobste.rs comments

Rye Tables vs Python/Pandas: A Different Way to Wrangle Data

Refaktor — Tue, 23 Sep 2025 18:43:09 +0000

If you’ve ever filtered a CSV in Pandas or written multiple nested for loops to group data in Python, you’ll probably find Rye’s take on the problem interesting.

Rye is a small, homoiconic language inspired by Rebol and Factor. One of its most interesting value types is the Table. A first-class, immutable data structure for tabular data.

Tables are mostly manipulated with pure, composable (endomorphic¹) functions. By using Rye's pipe and op-words, common wrangling tasks become small, chainable expressions.

This post compares how three different approaches handle the same data-wrangling problems:

Rye tables
Python with Pandas
Plain Python (no libraries)

Along the way we’ll look at what makes Rye’s model unique, where Pandas shines, and why pure Python becomes verbose as complexity grows.

Rye, in this case, is a programming language - not the package manager with the same name.

I worked on Rye for years before I saw a post about Rye - the package manager on HN. That tool seems to have been superseded by uv… so time fixes some confusions on its own. :P

Rye aims to be a higher higher-level language with value types that reflect more how people work with information vs. how computers work. One such value type is a Table.

To learn more about tables, visit the Cookbook page: Working with Tables.

#1: Filtering and Transforming Sci-fi books

Scenario: Given a dataset of sci-fi books, find all books published after 1980, add a column showing how old each book is, sort by age, and limit to top 2 results.

This first example represents a common data processing pattern: filtering, transforming, and sorting a dataset.

Rye

books: table { 'title 'author 'year }
{ "Neuromancer" "William Gibson" 1984
  "Snow Crash" "Neal Stephenson" 1992
  "Foundation" "Isaac Asimov" 1951
  "Dune" "Frank Herbert" 1965 }

books .where-greater 'year 1980
|add-column 'age { year } { 2025 - year }
|order-by 'age 'asc
|columns? { 'title 'author 'age }
|display

; Prints:
; | title       | author          | age |
; +-------------+-----------------+-----+
; | Snow Crash  | Neal Stephenson | 33  |
; | Neuromancer | William Gibson  | 41  |

Rye's example is written using pipe-words ( |word ), very common to Rye, and a fact that base Table functions are endomorphic. They accept a table and return a new table. This means you can compose and combine them in any order you need them to.

Find out more about Rye's op and pipe-words

Python Pandas

Pandas supports very similar concepts, so the code is very similar in shape and size.

import pandas as pd

books = pd.DataFrame([
    {"title": "Neuromancer", "author": "William Gibson", "year": 1984},
    {"title": "Snow Crash", "author": "Neal Stephenson", "year": 1992},
    {"title": "Foundation", "author": "Isaac Asimov", "year": 1951},
    {"title": "Dune", "author": "Frank Herbert", "year": 1965}
])

result = (books[books['year'] > 1980]
         .assign(age=lambda x: 2025 - x['year'])
         .sort_values('age')
         [['title', 'author', 'age']])
print(result)

Pandas does introduce some unusual syntax for Python that is not that self-explanatory. It seems to
heavily utilize the accessor syntax.

books[books['year'] > 1980]
[['title', 'author', 'age']]

Python

Contrary to the above two, pure Python is a staple of imperative code, for its good and its bad. It's a little
more verbose, but it's very basic and not hard to see what exactly is going on.

books = [
    {"title": "Neuromancer", "author": "William Gibson", "year": 1984},
    {"title": "Snow Crash", "author": "Neal Stephenson", "year": 1992},
    {"title": "Foundation", "author": "Isaac Asimov", "year": 1951},
    {"title": "Dune", "author": "Frank Herbert", "year": 1965}
]

# Filter books after 1980
filtered_books = []
for book in books:
    if book["year"] > 1980:
        filtered_books.append(book)

# Add age column
for book in filtered_books:
    book["age"] = 2025 - book["year"]

# Sort by age
filtered_books.sort(key=lambda x: x["age"])

# Display a specific table
print("| title | author | age |")
print("+-------+--------+-----+")
for book in filtered_books:
    print(f"| {book['title']:<12} | {book['author']:<15} | {book['age']:2} |")

Despite its simplicity, contrary to the above examples this code doesn't display intent. We see 3 for loops but each is
used for an absolutely different purpose. So comments that explain intent make sense here.

#2: Joining and Aggregating Space Colonies

Scenario: Join colony data with planet information, then group by planet type to calculate total population and average colony size, and save the result as an Excel (.xlsx) file.

Moving beyond simple transformations, this example tackles relational operations—joining datasets and performing aggregations.

Rye

colonies: table { 'id 'name 'planet_id 'population }
{ 1 "New Terra" 1 50000
  2 "Olympus" 1 75000
  3 "Titan Base" 2 12000 }

planets: table { 'id 'name 'type }
{ 1 "Mars" "Terrestrial"
  2 "Titan" "Moon" }

colonies .inner-join planets 'planet_id 'id
|group-by 'type { 'type count 'population sum 'population avg }
|save\xlsx %colonies.xlsx
|display

; Prints:
; | type        | type_count | population_sum | population_avg |
; +------------------------------------------------------------+
; | Terrestrial | 2          | 125000.000000  | 62500.000000   |
; | Moon        | 1          | 12000.000000   | 12000.000000   |

In Rye even what are usual special forms are just functions, and this example just uses a few more functions.
Like add-column in the first example, that accepted a table and two blocks of code/data. Here we have a group-by
function with its third argument as its own little microdialect for specifying column to aggregate on and aggregate functions to use.

Rye dialects often rely on Rye's many word types. Here a lit word ( 'word ) or string would denote a column and a word ( word ) denotes
an aggregate function to apply.

Python Pandas

import pandas as pd

colonies = pd.DataFrame([
    {"id": 1, "name": "New Terra", "planet_id": 1, "population": 50000},
    {"id": 2, "name": "Olympus", "planet_id": 1, "population": 75000},
    {"id": 3, "name": "Titan Base", "planet_id": 2, "population": 12000}
])

planets = pd.DataFrame([
    {"id": 1, "name": "Mars", "type": "Terrestrial"},
    {"id": 2, "name": "Titan", "type": "Moon"}
])

result = (colonies.merge(planets, left_on='planet_id', right_on='id')
         .groupby('type')['population']
         .agg(['count', 'sum', 'mean'])
         .reset_index())

# Save to Excel file (requires: pip install openpyxl)
result.to_excel('colonies.xlsx', index=False)
print(result)

Again, Pandas example is of similar shape as Rye one. And again it seems we use some magical accessor syntax:

.groupby('type')['population']

Python

colonies = [
    {"id": 1, "name": "New Terra", "planet_id": 1, "population": 50000},
    {"id": 2, "name": "Olympus", "planet_id": 1, "population": 75000},
    {"id": 3, "name": "Titan Base", "planet_id": 2, "population": 12000}
]

planets = [
    {"id": 1, "name": "Mars", "type": "Terrestrial"},
    {"id": 2, "name": "Titan", "type": "Moon"}
]

# Manual join operation
joined_data = []
for colony in colonies:
    for planet in planets:
        if colony["planet_id"] == planet["id"]:
            joined_row = {**colony, **planet}
            joined_row["planet_name"] = planet["name"]
            joined_data.append(joined_row)

# Manual grouping and aggregation
from collections import defaultdict
groups = defaultdict(list)
for row in joined_data:
    groups[row["type"]].append(row)

results = []
for planet_type, group_data in groups.items():
    total_pop = sum(row["population"] for row in group_data)
    avg_pop = total_pop / len(group_data)
    results.append({
        "type": planet_type,
        "count": len(group_data),
        "total_population": total_pop,
        "avg_population": avg_pop
    })

# Display results
print("| type | count | total_pop | avg_pop |")
print("+------+-------+-----------+---------+")
for result in results:
    print(f"| {result['type']:<11} | {result['count']:3} | {result['total_population']:8} | {result['avg_population']:7.0f} |")

# Note: Excel export would require additional libraries like openpyxl or xlsxwriter.
# We don't save to Excel here.

This example highlights how complexity scales differently across approaches. The manual Python implementation becomes significantly more verbose when dealing with joins and aggregations, while both Pandas and Rye maintain relatively concise syntax.

Interactively solving Examples #1 and #2

You can visit asciinema to see the first two examples run interactively in a Rye console (REPL) while displaying the intermediate results.

Rye focuses on being especially useful in an interactive setting.

#3: Nesting multi-table Exoplanet data

Scenario: Read 3 CSV files containing exoplanet data, observations, and station information. For each exoplanet, collect the top 3 observations (by confidence) and sum the population of all stations stationed near that exoplanet. Output as multi-layered JSON.

This example demonstrates more complex relational operations across multiple tables, joining data, nested aggregations, and structured output generation.

For better information organisation we load all data into a data context. All functions here again are endomorphic.

Rye

data: context {
    load\csv %exoplanets.csv |autotype 0.95 :exoplanets
    load\csv %observations.csv |autotype 0.95 :observations
    load\csv %stations.csv |autotype 0.95 :stations
} 

data/exoplanets
|add-column 'observations { id } {
    data/observations
    |where-equal 'exoplanet_id id
    |order-by 'confidence 'desc
    |columns? { 'date 'notes }
    |head 3
}
|add-column 'stationed_population { id } {
    data/stations
    |where-equal 'stationed_near id
    |column? 'population
    |sum
}
|drop-column 'id
|to-json
|print

This example uses the fact that Table is a basic Rye value type, so it only makes sense that table cells can also hold tables. We add a column to the base table
that holds tables to the top 3 observations, and we add another where we manually aggregate a value to its sum.

Python Pandas

import pandas as pd
import json

# Load CSV files with automatic type inference
exoplanets = pd.read_csv('exoplanets.csv')
observations = pd.read_csv('observations.csv')
stations = pd.read_csv('stations.csv')

# Functional approach with `apply()` requires helper functions for nested operations
def get_observations_for_exoplanet(exoplanet_id):
    """Get top 3 observations for an exoplanet, ordered by confidence desc"""
    filtered_obs = observations[observations['exoplanet_id'] == exoplanet_id]
    sorted_obs = filtered_obs.sort_values('confidence', ascending=False)
    top_obs = sorted_obs[['date', 'notes']].head(3)
    return top_obs.to_dict('records')

def get_stationed_population(exoplanet_id):
    """Get sum of population for stations near an exoplanet"""
    filtered_stations = stations[stations['stationed_near'] == exoplanet_id]
    return int(filtered_stations['population'].sum())

# Add nested observations and stationed population data
exoplanets['observations'] = exoplanets['id'].apply(get_observations_for_exoplanet)
exoplanets['stationed_population'] = exoplanets['id'].apply(get_stationed_population)

# Remove the id column and convert to JSON
result_json = exoplanets.drop('id', axis=1).to_json(orient='records', indent=2)
print(result_json)

In this case the code between Pandas and Rye is not so similar. It seems Pandas requires the use of
helper functions, that are then applied to get the aggregated / nested values.

Python

import csv
import json
from collections import defaultdict

# Load exoplanets
exoplanets = []
with open('exoplanets.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        row['id'] = int(row['id'])
        row['mass'] = float(row['mass'])
        row['radius'] = float(row['radius'])
        row['temp'] = float(row['temp'])
        row['discovery_year'] = int(row['discovery_year'])
        exoplanets.append(row)

# Load observations
observations = []
with open('observations.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        row['exoplanet_id'] = int(row['exoplanet_id'])
        row['confidence'] = float(row['confidence'])
        observations.append(row)

# Load stations
stations = []
with open('stations.csv', 'r') as file:
    reader = csv.DictReader(file)
    for row in reader:
        row['population'] = int(row['population'])
        row['stationed_near'] = int(row['stationed_near'])
        stations.append(row)

# Group observations by exoplanet_id for efficient lookup
obs_by_planet = defaultdict(list)
for obs in observations:
    obs_by_planet[obs['exoplanet_id']].append(obs)

# Group stations by stationed_near for efficient lookup
stations_by_planet = defaultdict(list)
for station in stations:
    stations_by_planet[station['stationed_near']].append(station)

# Process each exoplanet
for exoplanet in exoplanets:
    planet_id = exoplanet['id']

    # Get top 3 observations by confidence
    planet_observations = obs_by_planet[planet_id]
    planet_observations.sort(key=lambda x: x['confidence'], reverse=True)
    top_observations = []
    for obs in planet_observations[:3]:
        top_observations.append({
            'date': obs['date'],
            'notes': obs['notes']
        })
    exoplanet['observations'] = top_observations

    # Sum stationed population
    total_population = sum(station['population'] 
                          for station in stations_by_planet[planet_id])
    exoplanet['stationed_population'] = total_population

    # Remove the id column
    del exoplanet['id']

# Convert to JSON and print
result_json = json.dumps(exoplanets, indent=2)
print(result_json)

The pure-Python version quickly becomes verbose, so we would have to heavily refactor it or of course use
a library like Pandas.

Example inputs

The three csv files we use in the example above:

exoplanets.csv

id,name,mass,radius,temp,discovery_year
1,Kepler-296e,1.79,1.5,251,2014
2,TOI-715b,3.02,1.55,280,2023
3,Gliese-667Cc,3.8,1.5,277,2011

observations.csv

exoplanet_id,date,confidence,notes
1,2015-01-20,0.95,Primary transit detected
1,2015-02-15,0.92,Secondary eclipse confirmed
1,2020-03-10,0.98,Follow-up observation
2,2015-01-18,0.89,Initial detection
3,2014-05-12,0.94,Multiple transits observed
2,2014-08-30,0.96,Orbital period confirmed
3,2014-05-12,0.88,Shallow transit
3,2014-11-15,0.90,Period validation
3,2023-02-14,0.97,Recent discovery

stations.csv

name,population,stationed_near
Alpha Station,15000,1
Beta Outpost,8500,2
Gamma Research Base,2300,1
Delta Mining Station,12000,1
Epsilon Colony,45000,3
Zeta Trading Hub,22000,3

Example output

This is the JSON output that running a Rye script for example 3 produces.

[
  {
    "name": "Kepler-296e",
    "mass": 1.79,
    "radius": 1.5,
    "temp": 251,
    "discovery_year": 2014,
    "observations": [
      {
        "date": "2020-03-10",
        "notes": "Follow-up observation"
      },
      {
        "date": "2015-01-20",
        "notes": "Primary transit detected"
      },
      {
        "date": "2015-02-15",
        "notes": "Secondary eclipse confirmed"
      }
    ],
    "stationed_population": 29300
  },
  {
    "name": "TOI-715b",
    "mass": 3.02,
    "radius": 1.55,
    "temp": 280,
    "discovery_year": 2023,
    "observations": [
      {
        "date": "2014-08-30",
        "notes": "Orbital period confirmed"
      },
      {
        "date": "2015-01-18",
        "notes": "Initial detection"
      }
    ],
    "stationed_population": 8500
  },
  {
    "name": "Gliese-667Cc",
    "mass": 3.8,
    "radius": 1.5,
    "temp": 277,
    "discovery_year": 2011,
    "observations": [
      {
        "date": "2023-02-14",
        "notes": "Recent discovery"
      },
      {
        "date": "2014-05-12",
        "notes": "Multiple transits observed"
      },
      {
        "date": "2014-11-15",
        "notes": "Period validation"
      }
    ],
    "stationed_population": 67000
  }
]

More information

If you find Rye tables interesting, you can read more about them in the Cookbook page:

Cookbook / Working with Tables

To read more about the concepts and specifics of Rye visit:

For code, visit: Rye's Github

Conclusion

Should you ditch Python and Pandas and use Rye? Of course not. Rye is still a work in progress programming language and it's nowhere near
stability and functionality compared to Python or Pandas.

I would love feedback on the concepts and whether Rye's table abstractions could fit into your workflow. I’d also love suggestions on how to make it even more useful and internally consistent.

Here, it means table functions accept a table and return a new table, so you can stack them together without losing type consistency.

Updates after publishing

15.Sep.2025 - A lot of comments we got mentioned Python Polars library, that also made some similar design decisions (immutability, endomorphism). I will look into it.

15.Sep.2025 - A user n1000 from Lobste.rs wrote the same examples in R language. R is a popular lanuauge for statistics, data science, visualisation, and has a DataFrame value type, which was also one of inspirations for Tables. Examples in R

16.Sep.2025 - Comments on lobste.rs are interesting and provide more ideas and information lobste.rs thread

Endomorphic means “mapping a set onto itself.” ↩

Working on a Programming Language in the Age of LLMs

Refaktor — Fri, 25 Jul 2025 11:39:42 +0000

genie

I've been working on Rye since 2018. It's a project of joy — but also because I believe there is a potential to create something of value to others, eventually.

Even people living under a rock know we've entered the age of LLMs. I don't jump to ships too soon, but eventually, even I had to admit:
code can get generated from prompts. And in many situations — with a smart prompter — the results are quite OK.

Even if you disagree, genie can't be put back in the bottle. Technical progress generally only moves forward.

buzz

Trying to persuade programmers to switch to a language you made up is very ambitious (or just mad) on its own. When all the buzz is about not needing to use any programming language
at all, it makes even less sense.

The falling tide lowers all boats — and my is not even in the water yet.

killing

LLMs currently need programming languages, they can't just generate executables directly from your prompt. Absurdly they also need examples, tutorials, blogposts, Stack Overflow answers,
which they are now well, killing.

LLMs are on the level of transpiler languages (Coffeescript?). They need the host languages — but if really succsessful, they would end up killing the host.

If no one uses Python anymore, will anyone still work on Python? (Just an example.)

Probably, in the long term, LLMs* will have/generate their own runtimes, libraries, and everything else. (* Or what comes next.)

specific

So the real question — does it make sense to keep developing Rye? — boils down to:

Is natural language the best substrate to declare what you want from a computer?

Traditionally, programmers believed it isn’t. But maybe it’s a matter of specificity.
Yes, natural language can be used to declare any solution — but it’s not ideal for declaring a specific one.

"Make me a Flutter app where I can jot down recipes and rate them" **vs.**

Specific storage. Specific structures. Specific behavior. Specific interface...

Specialized languages—with consistent, exact, and repeatable design—will beat natural language at that.
Like any specialized tool beats a general one at the task it’s built for.

thoughts

Languages are not just tools for communication. They are also tools for thinking.

Medical jargon helps doctors communicate, store information — and also think about medical issues.
SQL helps us think about data and its relationships.
Functional languages help us solve problems that compose better and cleaner (with less state).

These aren’t just syntax choices — they’re cognitive frameworks.

If we lose tools for precise thought, we may lose the ability to have precise thoughts altogether.

yesterday's

LLMs are trained on **yesterday's* solutions*. They are good at recombining existing patterns, even in novel ways, but they are fundamentally backward-looking.

If we stop developing better ways of expressing computational ideas — is this it?
Does progress stop here?

monkeys

This also leads to a question (inspired by certain monkeys on typewriters) I asked LLMs a few times:

If you leave 100 LLMs chatting for 100 years, will they come up with any original thought?

Or would they simply recombine existing knowledge in increasingly sophisticated ways — trapped in an echo chamber of human-generated training data?

Ask your favorite LLM.

And yes — I still think it makes sense to build a language. Maybe more than ever.

Originally published on Ryelang blog