@nycki ohh - that definitely makes sense! you almost need like a database schema or something. that sounds like an interesting problem to solve. maybe you could even include type information in the schema, so that the nifty could be type-checked at the same time that it’s being converted

@nycki I haven’t unfortunately, but I love this! when I was younger I experimented with a ton of different languages that transpiled into HTML, but they often had weird implicit rules or syntax that I had a hard time getting an intuition for. this feels dead simple, easy to learn, and much easier to read too

quote are optional around one-word strings

hmm, another possibility would be to steal from Lisps (especially Fennel) and have one-word strings be quotable using a prefixed : like this:

(div
  ((p class :foo "Hello, world!")
   (p class :bar "some text")))

I think that would probably be how I would do it (edit: actually, I guess in this case class doesn’t need to be quoted but foo does, but what makes class special here? maybe it would be :class :foo instead)

also I’m curious what JSON would look like in nift! JSON is already fairly terse, but has some annoying syntax rules (like no leading commas, and no comments allowed)

@nycki I’m so glad you like the idea so much! 💙

come to think of it, you could fix the noisiness by having two sets of syntax: the usual long-form { } syntax and a short-form [ ] syntax for when you want to make a simple, quick literal:

let someNums = [1, 2, 3, 4]
let aDict = [
    "foo" = "bar",
    "baz" = "qux",
    1337 = 7331,
]

both would create the same type of value (a Lua-style table) but one would be a shortened form of the other

imagine a language like Lua except every table literal is actually a block of code that is run like a module. for example:

let someTable = {
    export someValue = "foo"
    let privateValue = "bar"
}

print(someTable.someValue)
# prints "foo"

print(someTable.privateValue)
# error

that would mean that when you require("someModule") you’re essentially wrapping the entire someModule file inside of { } and getting the result

it would make table literals more noisy but it would also let a Lua-like language have even fewer concepts that need to be learned in order to understand it

plus, you could define a whole class inside of one set of { } which would make the syntax mirror how most other languages do classes - and create a visual divide between the class and any unrelated stuff that might exist in the same file:

let SomeClass = {
    export new = (value) -> {
        let newInstance = {
            let privateValue = value
        }

        setmetatable(newInstance, this)
        return newInstance
    }

    export getValue = (this) -> {
        return this.privateValue
    }

    export setValue = (this, value) -> {
        this.privateValue = value
    }
}

let instance = SomeClass.new("foo")

you could even make it so that if you return inside of { } then the whole { } block evaluates to whatever you returned, so you can have multiple statements inside of your expressions (and not just table expressions) just like in Lisp:

let fibonacciNums = {
    let a, b = 0, 1
    let nums = {}

    for _ in range(100) do
        a, b = b, a+b
        list.push(nums, a)
    end

    return nums
}

print(fibonacciNums)
# {1, 1, 2, 3, 5, ...}

@harmonycorrupted @trinityblair I’m curious why not - do they have bad associations with the platform, or just see it as too niche?

Oh, I forgot. The CD player I just bought also comes with a comic.

It says they carefully retrieved my product from their inventory with sterilized anti-bacterial gloves and placed it on a satin silk cushion.

The party they organized to celebrate my order lasted 3 days. When the time came, the clamoring crowd cheered through the city as the procession made its way to the post office.

A team of 50 experts proceeded to inspect the product. They polished it until it shine and bid it farewell with a tender caress.

The postal service then took over, using one of their many private jets to send your product as fast as possible. Give. It's inestimable value, two fighter jets were dispatched to ensure it's safe arrival.

Their internationally renowned packaging specialist (who came straight from Korea (lit candles and incense sticks. Absolute silence set as he placed the product in its box.

They've placed my photo in a 50x50 food frame and selected me as customer of the century. (Unfortunately this position may be contested in the year 2100).

They then offered to send me another version of this comic with a real photo of me (or my pet) on it that's printable.

Random violin teaching moment

One my favorite questions to ask is: “What did we do in here together that you wouldn’t have thought to do on your own?”

A primary goal for me as a teacher is to teach students how to teach themselves. I want them to be as independent as possible and have the tools to learn and play music on their own

💜

It is depressing if someone experiences hate on here, especially if it puts them off using this place.

I follow people that regularly raise these issues, to hear how bad it is and what the causes are.

Five things seem to come up most often:

- Lack of representation in software design
- Users not being able to control who can reply to their posts
- Moderation being reactive rather than proactive
- Allowlists vs blocklists
- Cultural problems

Let's look closer...

🧵 Thread - Part 1 of 7

People say you shouldn't compare apples and oranges but it seems to work fine for me in Python 3.14, I don't see what the issue is...

The Japanese Bee Fly mimics a bee, is super cute and was the inspiration for the Pokemon Cutiefly

Hey Fedi,

How are you doing today?

Everything okay? Do you need a hug?

I bet you could use a hug.

🫂

a thing about Lisps that I find very beautiful is that you can learn their basic rules (syntax, macros, and execution) very quickly and easily*, and after that point you’ll understand all you need in order to make sense of anyone else’s code (as long as you can look up the forms that they’re using). you’ll never run into a situation where you don’t know what you’re looking at, syntactically speaking - which can happen a lot in non-Lisp languages

but a big complaint that I have about Racket is:

• compared to other Lisps, it has a lot of special-case syntax
• there’s no single place in the Racket Guide (the friendly, readable reference guide for Racket) that explains all of the syntax. instead, the syntax is spread throughout the guide
• there is a single place in the Racket Reference that explains all of the special-case syntax, but the Racket Reference is an extremely dense and challenging read (I’m not entirely sure why they decided to write it this way. it reads more like a formal standard for the language than a reference guide. everything is explained in excruciatingly precise detail and there is a lot of Racket-specific jargon being thrown around as well)

I get the feeling that Racket is overall a very complex and densely-packed language - designed to give users as many options as possible. and I have mixed feelings about that approach. it makes the language less beautiful to me, and harder to learn, but there might be a lot of practical value in doing things that way

* nothing involving programming is quick and easy, but it’s “very quick and easy” compared to learning the equivalent information in almost any other language

first impressions of #Racket seem pretty good! it has some stuff that I don’t like from other Lisps like:

• a weird pseudo-module system instead of a proper module system
• an unnecessarily large number of ways to compare values
• several forms that implicitly add new functions to the namespace

it’s also a very very complex language compared to Janet or Fennel. but the things that I really like about it are:

• the Racket folks clearly care deeply about people’s first time experience with the language and have made it incredibly smooth and easy in many different ways (they even have a nice, friendly little IDE called DrRacket that comes with every Racket installation)
• it has easy, out-of-the-box Windows support! (this is pretty rare with Lisps)
• the documentation is fantastic. it’s not just incredibly thorough and well-explained, it’s also split into {documentation for beginners} and {full and complete documentation for masochists} sections, and everything is heavily linked together with hyperlinks to more documentation that explains things even further

my overall first impression of Racket is that it’s the Python of Lisps: it’s very complex and full-featured, but it also cares deeply about being as easy and friendly for beginners as possible, and I think that’s one of the most important traits for a language to have