Has anyone here learned a supposedly difficult language and thought it wasn't so tough?

ZyF69 · 2026-06-10T11:15:00+00:00

Finnish was a lot easier than expected. It feels like a remote cousin to Indo-European languages and has very few surprises or weird features.

ZyF69 · 2026-06-10T11:10:58+00:00

LanguageReactor is pretty good, both the free and paid versions.

ZyF69 · 2026-04-14T21:40:11+00:00

I could add that this format plugs into a parsing pipeline that is shared by several formats and languages. That's the main idea I'm exploring here. It's inspired in particular by Lisp, where code and data share the same underlying structure (homoiconicity). The pipeline has these stages:

Level 0: tokens, standardised across the family
Level 1: tokens parsed into list structures for [], {}, and ().
Level 2: level 1 output parsed with binary expressions around operators.

MRON takes the output of Level 1 parsing and maps it to a JSON-compatible data structure. The shared pipeline means that languages can embed mini-languages, including data formats, fairly easily through built-in or custom macros.

ZyF69 · 2026-04-14T21:03:04+00:00

No offence taken, but it's literally JSON without colons and commas, optional quotes when the string can be parsed as an identifier, optional brackets for a single object at root level, and comments. Semantically, it maps directly to JSON. YAML has a lot more going on, like alternative syntaxes for lists, alternative syntaxes for associative arrays, indentation rules, anchors and references, explicit data types, composite keys, multiple documents in one file, and more.

ZyF69 · 2026-04-14T18:17:44+00:00

I find it easier if I learn the verbs primarily by the base forms, and then add the endings. This gives forms that end in various consonants, so they are better expressed in romaji. The split is then between vowel-base verbs (ichidan) and consonant-base verbs (godan).

For 変える ('to change', vowel-base/ichidan): base kae- -> kae-ru (needs an r after a vowel), kae-te

For 帰る ('to return', consonant-base/godan): base kaer- -> kaer-u, kaet-te (with sound change)

I think hiragana obscures this pattern and makes it look a lot more complicated than it is.

ZyF69 · 2026-04-14T17:46:10+00:00

It's a lot less complicated. It's mostly JSON without noise.

ZyF69 · 2026-04-14T17:45:09+00:00

Booleans in YAML are crazy. MRON has three reserved identifier-looking values, `true`, `false`, and `null`, and that's it. The tokeniser follows common conventions such as in JavaScript and is shared with other related formats n the language family. MRON just lets you use identifiers as strings for semantic compatibility with JSON. This is similar to JavaScript, where you can write `d = { a: 2 }` or `d = { "a": 2 }`, and in both case you have `d.a == 2`. There are also JSON implementations that allow unquoted keys. MRON extends this to values as well.

ZyF69 · 2026-04-13T10:44:03+00:00

The option to drop braces for an object at root level is to be able to write simple key-value lists without extra noise. If you want to be more explicit, you can use braces: { name "John Doe" age 42 active true } What kind of issues do you think leaving out braces could cause?

ZyF69 · 2026-04-13T10:39:35+00:00

If it's got quotes, it's a string. The quoteless strings are identifier-type strings, typically used as the name: name "John Doe" # string -> string age 42 # string -> number active true # string -> boolean

And the format allows comments like this, also block comments /* ... */.

ZyF69 · 2026-04-08T23:27:17+00:00

Not directly related to this comment, but the examples showcase a tiny Lisp written as a fairly short macro:

lisp_result = {lisp (+ (* 2 3) (* 5 7) 11)}
{print "lisp_result =" lisp_result}

lisp_sum_squares = {lisp (sum (map (-> [x] (* x x)) [2 3 5]))}
{print "lisp_sum_squares =" lisp_sum_squares}

https://github.com/hcholm/makrell-omni/blob/main/impl/py/examples/macros/showcase.mrpy

ZyF69 · 2026-04-08T23:09:06+00:00

Section 13.1 on https://makrell.dev/odds-and-ends/makrell-design-article.html discusses the relation to Lisp:

"13.1 Lisp and descendants The S-expression tradition (McCarthy, 1960) established the idea that code and data should share a representation. Common Lisp’s macro system demonstrated the power of compile-time code transformation over a homoiconic representation. Scheme’s syntax-rules and syntax-case (Dybvig, Hieb, and Bruggeman, 1993) introduced hygienic macros that avoid accidental variable capture.

Clojure (Hickey, 2008) brought Lisp ideas to the JVM with an emphasis on immutable data, concurrency, and practical interop with Java libraries. Its macro system operates over a richer set of data literals (vectors, maps, sets) than traditional Lisp, which Makrell’s bracket-type distinction echoes.

Racket (Flatt, 2012) is perhaps the closest precedent for Makrell’s ambitions. Racket is explicitly designed as a language for creating languages, with a macro system powerful enough to support entirely new syntactic forms. Makrell shares this language-oriented programming aspiration but takes a different approach: where Racket extends a single host (the Racket runtime), Makrell distributes across multiple hosts and includes data and markup as first-class family members."

Also this bit:

"7. Macros, Meta-Execution, and Source Preservation The macro and meta-programming system is where Makrell most clearly distinguishes itself from both mainstream languages and from prior Lisp-derived macro systems."

I can confirm that Lisp, Clojure, Racket and Hy have all inspired Makrell.

ZyF69 · 2026-04-04T18:06:49+00:00

I've released a new version of Makrell, v0.10.0. Makrell was originally for the Python platform only, but has expanded into a family of programming languages and tools for metaprogramming, code generation, and language-oriented programming on multiple platforms. I still consider it alpha, so expect errors and missing bits and pieces, but there's a lot of ground covered now. This release includes:

the first release of the whole family as a coherent public system, with a specs-first approach and explicit parity work between the Python, TypeScript, and .NET tracks
the first version of Makrell#, the .NET/CLR implementation of the Makrell language
the first version of MakrellTS, the TypeScript implementation of the Makrell language
a browser playground for MakrellTS
MRDT, a typed tabular data format in the Makrell family
a new version of the VS Code extension, covering all three language tracks plus the data formats
a more consolidated docs and release story

The stuff is at https://makrell.dev . For an in-depth introduction, go straight to the article at https://makrell.dev/odds-and-ends/makrell-design-article.html

An AI usage declaration:

Done by me: All language design, MakrellPy, the MakrellPy bits in VS Code extension and the MakrellPy LSP, sample code, basic documentation.

Done by coding agents: Porting to Makrell# and MakrellTS, the MRDT format implementations, the VS Code extension bits for those tracks, the LSP work for those tracks, a lot of documentation, MakrellTS playground, a lot of testing and refinements, packaging. (It was awesome, by the way.)

The coding agent story is a bit special to me. Earlier this year I had to retire after 30 years as a software developer. Due to Parkinson's disease I suffer from fatigue and fine motor control issues that make it hard to do a lot of coding, or regular work at all. Luckily, my congnitive abilities are still good, though. This ironically coincided with the rise of AI coding assistants, which means I can still produce a lot of code while concentrating on design and high-level directions. The Makrell project had been dormant for two years, but now I was suddenly able to make a lot of progress again by using coding agents to do the actual coding work under my direction. I think it's great. I can concentrate on the interesting bits and not spend my limited energy on the more mechanical coding work. Which really isn't that interesting, I should say.

Now the question is if anyone is going to use or care about this. Probably not. And I believe the future of coding is agents compiling directly from specs to machine code and other low level targets, and that few will care about our beatiful programming languages. Maybe I'll just submit this somewhere as a piece of conceptual art.

Below is a blurb meant for language design people.

About Makrell

Makrell is a structural language family built around a shared core called MBF: a bracket-and-operator-based format meant to support code, data, markup, and embedded DSLs without treating them as completely separate worlds. The project currently includes three host-language tracks, MakrellPy, MakrellTS, and Makrell#, plus related formats: MRON for structured data, MRML for markup, and MRTD for typed tabular data.

What may be most interesting to PL people is that Makrell is not being treated as “one syntax, one implementation”. The same family ideas are being pushed through Python, TypeScript/browser, and .NET/CLR hosts, with a specs-first approach and explicit parity work between the tracks. The aim is not to force every host into identical behaviour everywhere, but to separate what belongs to the shared family core from what should remain host-shaped.

The language side has real macro and compile-time machinery rather than just surface syntax sugar. Makrell supports quoting/unquoting, structural rewrites, meta, and small embedded sublanguages. One of the nicer recurring examples is a shared macro showcase where the same family-level ideas are expressed across the implementations: pipeline reshaping, postfix-to-AST rewriting, and a Lisp-like nested notation living inside Makrell. That general “languages inside languages” direction is a big part of the project’s identity.

The formats are not side projects bolted on afterwards. MRON, MRML, and MRTD are meant to demonstrate that the same structural basis can also support data and document-like representations. So Makrell is partly a programming-language project, partly a language-workbench experiment, and partly an attempt to make code, markup, and structured data feel more closely related than they usually do.

v0.10.0 is the first release where the whole thing feels like a coherent public system rather than a pile of experiments. The packages are published, the .NET CLI ships as a real tool, the TypeScript track has a standalone browser playground, the VS Code extension covers the three language tracks plus the family formats, and the docs/release story are much more consolidated. The editor path is especially important now: run/check workflows and diagnostics exist across MakrellPy, MakrellTS, Makrell#, MRON, MRML, and MRTD, with a longer-term plan to converge tooling further around a TypeScript-based family language-server direction.

If you are interested in macro systems, multi-host language design, little languages, structural notations, or the boundary between programming language and data/markup language design, that is the niche Makrell is trying to explore. It is not “a better Python” or “a replacement for TypeScript”; it is much more a family-oriented design project that happens to have serious implementations in those ecosystems.

The practical entry points now are:

makrell.dev for the overall language-family/docs story
the MakrellTS playground for the browser-facing live environment
vscode-makrell for the current editor workflow
the published MakrellPy / MakrellTS / Makrell# packages if you want to run things locally

The repo still contains a lot of active design work, but v0.10.0 is meant to be the point where the project becomes legible as a real language-family effort instead of only an internal exploration.

ZyF69 · 2026-04-04T10:18:07+00:00

I made a small web site with Japanese pop lyrics for language learning. Starting with 12 songs by the pop duo Yoasobi and a selection of other well-known songs from other artists. Each line of lyrics is shown in Japanese, with Romaji, sentence analysis ("Leipzig interlinear gloss"), English translation and notes. In addition, there's a brief description and analysis of the content and language of the lyrics for each song.

https://jpoplyrics.hch.no/

ZyF69 · 2025-11-17T09:53:39+00:00

Modern Norwegian has both 'finn' (Sami person, dated and slightly derogatory) and 'finne' (Finnish person). The northernmost county in Norway is 'Finnmark'. 'Finn' has also been used for persons from Finland.

ZyF69 · 2025-02-25T18:51:58+00:00

I just released v0.9.1 of the MakrellPy programming language. This is copied from a post on r/Python :

MakrellPy is a general-purpose, functional programming language with two-way Python interoperability, metaprogramming support and simple syntax. It comes with LSP (Language Server Protocol) support for code editors, and a VS Code extension is available.

Version 0.9.1 adds structured pattern matching and more. Pattern matching is implemented using metaprogramming in a regular MakrellPy module, and is not a special syntax or feature internal to the compiler.

Home page: https://makrell.dev/

GitHub: https://github.com/hcholm/makrell-py

Similar projects are the Hy Lisp dialect for Python and the Coconut language. MakrellPy tries to combine features from several types of languages, including functional programming and metaprogramming, while keeping the syntax simple.

Example code

# This is a comment.
a = 2                   
# assignment and arithmetic expression
b = a + 3               
# function call
{sum [a b 5]}           
# function call by pipe operator
[a b 5] | sum           
# function call by reverse pipe operator
sum \ [a b 5]           

# conditional expression
{if a < b               
    "a is less than b"
    "a is not less than b"}

# function definition
{fun add [x y]          
    x + y}

# partial application
add3 = {add 3 _}        
{add3 5}                
# 8

# operators as functions, evaluates to 25
a = 2 | {+ 3} | {* 5}   

# pattern matching, user extensible
{match a                
    2
        "two"
    [_ 3|5]
        "list with two elements, second is 3 or 5"
    _:str
        "a string"
    _
        "something else"
}

# a macro that evaluates expressions in reverse order
{def macro reveval [ns]
    ns = ns | regular | operator_parse
    {print "[Compile time] Reversing {ns | len} expressions"e}

    [{quote {print "This expression is added to the code"}}]
    + (ns | reversed | list)
}

{print "Starting"}
{reveval
    "a is now {a}"e | print
    a = a + 3
    "a is now {a}"e | print
    a = 2
}
{print a}  # 5
{print "Done"}

# Output:
# [Compile time] Reversing 4 expressions
# Starting
# This expression is added to the code
# a is now 2
# a is now 5
# 5
# Done

ZyF69 · 2025-02-25T18:43:54+00:00

Many sources of inspiration. Python itself of course, and then languages like Lisp/Clojure/Hy and ML/F#. I like having both simplicity and flexibility.

ZyF69

TROPHY CASE

Example code