Lady @Lady@cat.family

@aescling listen to blood bitch

@wallhackio . @Satsuma was very impressed

@wallhackio i don't think your sister is coping well you should share some techniques

@wallhackio how does it feel to root for the losing team

@aescling the whole monarchist lions are innately king thing was always too much for me

@aescling not the part where the birdie gets lost in her tits but the part where maid marian is all princess daisy mario tennis

@aescling the badminton scene made me a lesbian

@aescling the lion king is bad so this tracks

@aescling you’re a furry

@aescling this does not help me evaluate whether it holds up

@aescling did you like it

@aescling have you seen sleeping beauty

@aescling @wallhackio “shake it out” is a florence + the machine song which is better

@aescling disney girl era?

@wallhackio @aescling well javascript doesn’t have any native concept of object type so in order to transform JS you have to first identify the type of every object and then call the methods associated with that type

“identify the type of object” can be trivial in the case where every object has a `type` property, but that’s still boilerplate you have to write and most real-world JSON is not this verbose

the end result of all this is that most code for processing JSON is incredibly bespoke

in XML on the other hand, the type of things is obvious (it's the node name), so you can just use a generic recursive descent mechanism with type-specific transforms, and you don’t have to write the first part because that’s XSLT

example JSON:

{ "type": "example"
, "items":
[ { "type": "item"
, "value": 1 }
, { "type": "item"
, "value": 2 } ] }

example XML:

<example>
<items>
<item value="1"/>
<item value="2"/>
</items>
</example>

desired result:

<p>Here are my items: {1}, {2}.</p>

XSLT conversion:

<x:template match="example">
<p>
<x:text>Here are my items: </x:text>
<x:for-each select="items/*"/>
<x:if test="position()!=1">
<x:text>, </x:text>
</x:if>
<x:apply-templates select="."/>
</x:for-each>
<x:text>.</x:text>
</p>
</x:template>
<x:template match="item">
<x:text>{</x:text>
<x:value-of select="@value"/>
<x:text>}</x:text>
</x:template>

conversion from JSON left as an exercise

suppose a new item type is added. with XML/XSLT, this just necessitates adding a single new template to handle it. how much does the code need to change to accommodate this with JSON?

@wallhackio @aescling there are thing which are very easy to do on s-expressions or in XML which are a pain in the ass to do with JSON and those things are basically all of the nature “convert this structure into that structure”

strong argument for just deserializing into a lisp, transforming, and serializing back, and that makes one wonder why you aren’t just using a lisp as your structure to begin with

@wallhackio @aescling nice