🪅-progaming

[deep mulch]

the kode tode

[supple whale]

is this actually useful?

i usually just do if (!('somekey' in value)) return

[royal nymph]

it's useful in certain cases yeah

like a discord message

if it comes from anywhere, things like msg.guild, msg.channel etc can differ

so you have to manually check all those members

you can instead do like

isInGuildChannel() this is GuildChannelMessage {
    return this.guild !== null;
}

if (msg.isInGuildChannel()) {
    msg.channel // typed correctly
    msg.guild // typed non null
} else if (msg.isInDm()) {
    msg.channel // DMChannel
    msg.guild // null
}

nicer alternative to manual casting

[ionic lake]

isVen() this is Ven {
return this.person.kind === 'cute';
}

[supple whale]

if ('guild' in msg) {
    msg.channel // typed correctly
    msg.guild // typed non null
} else if ('dm' in msg) {
    msg.channel // DMChannel
    msg.guild // null
}

does the same tho?

[royal nymph]

way uglier and not as powerful :P

you can have way more advanced assertions

[valid jetty]

function isCute(): this is Cute {
    return this.message.reader === 'you';
}

[supple whale]

TS infers that the msg is a GuildChannelMessage, and you dont need and TS specific syntax

[cobalt ledge]

Can you patch the content in /assets?

[fleet cedar]

Yes, that's where the webpack is

[valid jetty]

yeah level 5 devs make a lot of syntax errors

nvm its not

but why is he casting a nullptr to a function that returns void

[hoary sluice]

void* 0 but i inserted 10 trillion parentheses

[deep mulch]

@valid jetty I will cast you to a void pointer

[valid jetty]

no

void(*x)(int) is a function signature in C

void(*)() is a signature that takes no args and returns void

theyre casting 0 to that, then inline-calling it

[deep mulch]

@valid jetty find my pointers

[hoary sluice]

so effectively the same thing

[valid jetty]

casting 0 to a void* and casting 0 to a function that returns void are very different things

though the result is the same

[hoary sluice]

both crashes the program

[valid jetty]

yeah, a segfault

[fleet cedar]

Casting 0 to a pointer, whether void or void(), is no problem; it doesn't break until you dereference/call it

[hoary sluice]

rain doesnt come from clouds unless it rains

[fleet cedar]

Do you?

[jade stone]

afaik thats 100% possible

[winged mantle]

how

[hoary sluice]

@valid jetty lol thats like 80% of the project

[valid jetty]

chore: lint

lmfao

[deep mulch]

@valid jetty hiii

[valid jetty]

@deep mulch minklang

[hoary sluice]

i cargo fmt and cargo clippy --fix before every commit

with pedantic clippy

altho yea this was a clippy lint

[valid jetty]

I KNEW IT

LMAO

[deep mulch]

soon

[hoary sluice]

pretty sure you have module inception allowed

[valid jetty]

what

[hoary sluice]

oh i didnt show the commit msg

refactor: fix module inception

[valid jetty]

yeah no i do

i personally dont mind that pattern

[hoary sluice]

ig this is completely unrelated if theres no commit message visible

[hoary sluice]

meh

[valid jetty]

lmao yeah

[hoary sluice]

lexer/mod.rs
mod lexer;

this does not need to be its own file

[valid jetty]

isnt mod.rs necessary

[hoary sluice]

i think so, but theres no need to put the lexer into lexer.rs and use it in mod.rs when it can go into mod.rs

[valid jetty]

or just

// lexer/mod.rs
mod lexer;
use lexer;

[hoary sluice]

u mean pub use?

[valid jetty]

yeah

[hoary sluice]

this is what i had

whats the point

[valid jetty]

organization

[hoary sluice]

just put it into mod.rs

[deep mulch]

@valid jetty rewrite Elle

[valid jetty]

eventually i will

[hoary sluice]

this is why i have stayed on approx the same loc for months

[valid jetty]

i wanna make the lexer return an iterator lmao

so i can do what i did in いちご

[hoary sluice]

rewrite lexer and parser in elle

[valid jetty]

oh great my zed broke again because i ran out of storage

fuck this stupid 256gb ssd size

[hoary sluice]

macbook:

[valid jetty]

ok well whatever

fn Lexer::iter(Lexer self) -> Iterator<Token, Lexer, SingleEnded> {
    return Iterator {
        env = Box::new(self),
        next = Lexer::next_token,
        next_back = nil
    };
}
``` i did this in いちご

the lexer is the Env

[hoary sluice]

rewrite lexer and parser in elle

[valid jetty]

then in main you literally do this

tokens := Lexer::new(args[0]).iter().collect();

this is it

[valid jetty]

i could do

but that means serializing the AST into some form the rust needs to read

for codegen

im not doing codegen in elle

[hoary sluice]

this is what im spending my next paycheck on https://www.tuxedocomputers.com/en/TUXEDO-Sirius-16-Gen2-Pre-built--48h-Shipping.tuxedo

or maybe a framework

[hoary sluice]

y

[valid jetty]

difficult

possible but slightly annoying

idk what to tell you but this code so clean

use std/prelude;

use lexer/lexer;
use parser/parser;
use compiler/compiler;

fn main(string[] args) {
    program := args.remove(0).expect("プログラム");
    file := args.remove(0).expect("使い方: {} file.igo\n".format(program));

    tokens := Lexer::new(file).iter().collect();
    tree := Parser::new(tokens).parse();
    module := Compiler::new(tree).compile();

    io::write_to_file(file.replace("igo", "ssa"), "{}".format(module));
}

[winged mantle]

it feels scary that unicode works without jumping through hoops

[deep mulch]

just say the English word

I can't even pronounce that

[valid jetty]

it doesnt

it may be able to be put inside strings but you cant manipulate those strings

its an array of bytes not an array of utf8 chars

[hoary sluice]

you know what it means

[valid jetty]

i wrote a custom utf8 lib for working with utf8 here

[deep mulch]

nop

everyone here speaks English so just send the English name

[valid jetty]

関数　同一（整数　値）『
    返す　値。
』

関数　気持ち（）『
    返す　「大好き〜」。
』

関数　メイン（）『
    ※これはコメントです
    整数 フウ ＝　同一（39）。
    文字列　バル ＝　気持ち（）。
    プリント（「%dが%s:3\n」、フウ、バル）。
    プット（「彼女は「にゃ〜」と言ったの」）。
』

[deep mulch]

you are addicted I think

[valid jetty]

no

[deep mulch]

yes

[valid jetty]

the point is that the language is supposed to be fully jp

[deep mulch]

[nimble bone]

guhh hop off complaining

everyone knows what it means

[valid jetty]

yeah smh

[lavish cloud]

I figured out how to notifications

[deep mulch]

guh

[lavish cloud]

Hihi zoot

I made a website in compose the other day

wbu

[deep mulch]

hi

I am rewriting an app to use compose

[lavish cloud]

Ooo

[shrewd canopy]

I am considering to make site in C++ with Qt

[lavish cloud]

I should make a mobile app for my site but idk how to do webview content stuff

[lavish cloud]

Til Qt supports web

[deep mulch]

horror

[lavish cloud]

Oh yeah look at that

Qt for WASM

[royal nymph]

rewrite minkinator with compose

[deep mulch]

how

there's no ui

[royal nymph]

idk

[deep mulch]

gu

[frosty obsidian]

https://github.com/JakeWharton/mosaic

tui dashboard for minkinator

[deep mulch]

guhh

[barren nacelle]

guy

guys

i joined this server soully to say i added an extra intensity to party mode

i fittingly named it lord and boy is it a mess

[lavish cloud]

W hat

[fleet cedar]

Build terminal UI in Kotlin using Jetpack Compose

[lavish cloud]

Cursed

[pulsar elk]

bruh

[ionic lake]

I used ink and it was so painful

Yoga is just bog slow and huge

You're better off using rust and ratatui

[formal belfry]

This looks like garbage lol

[dense sand]

is there anyone who can help me with writing revanced fingerprint?

cause like my fingerprint is failing to be found

[fleet cedar]

Look on the nearest polished glass surface

[ionic lake]

probably ask in the revanced server

[dense sand]

ugh...

[valid jetty]

this is just a terrible idea

oh my god stop trying to put react in everything 😭

bloat central

top 3 ink users are ai slop

should give an idea of what kind of tool this is

[fleet cedar]

React is probably easier to vibe code, makes sense that vibe coding tools would want to use it

[valid jetty]

true

[fleet cedar]

Rewrite react in react

[balmy lintel]

my internet so bad it showed the message twice but it sent only once

now it deleted both messages

[pulsar elk]

how the fuck do i access the battery % and battery life/metrics

losing it

[fleet cedar]

On what platform

/sys/class/power_supply/BAT0 on linux

[royal nymph]

Linux trying not to make everything a pseudofile

[fleet cedar]

But "everything is a file" is like, linux's slogan

[hoary sluice]

@valid jetty never use rust and docker on a raspi

[deep mulch]

/dev/vee

[hoary sluice]

building my voice assistant takes 20 minutes

[deep mulch]

@royal nymph i will make vee file

[hoary sluice]

3k loc 300 deps

[deep mulch]

every time im in my documents folder the prompt has one leading space and its driving me insane

its only the documents folder

[valid jetty]

its the deps

[dense sand]

rust skill issue

troll~2

[ionic lake]

every language has a dependency problem tbf

only if you're disciplined then you wouldn't have so many deps

[fleet cedar]

Resisting NIH is what takes discipline

More deps means more code you didn't have to waste time rewriting a worse copy of

[winged mantle]

you do NOT need 300 deps

[shrewd canopy]

So real

[ionic lake]

most of the time you could just take the code and fit in your codebase or simplify it

[winged mantle]

I once used a random timestamp formatting library from npm

it seemed more complicated to get it to work how i wanted than just writing it myself

[ionic lake]

you can add deps, but to some degree that the dep itself doesn't do beyond what it needs to do for its job

[winged mantle]

I feel like there's nothing inherently wrong with doing things which have been done before

i think as a rule of thumb the one time where you mostly should be using a library is when you need something that implements a specification like http or json

[nimble bone]

i should rewrite apprev to only use the node WebSocket

and try going zero dependency

tbf it sounds easy it already hooks into the gateway for 99% of what it does

dependencies": {
"esbuild": "^0.25.3",
"oceanic.js": "^1.12.0",
"sqlite": "^5.1.1",
"sqlite3": "^5.1.7",
"tsx": "^4.19.4",
"typescript": "^5.8.3"
},

[winged mantle]

or I guess a better way to say that is the one time you're mostly foolish for not using a library is when you need something which implements a specification

[nimble bone]

should i try implementing sqlite @winged mantle

or i go back to Json database and state object

https://git.nin0.dev/nin0/grok-api/src/branch/main/src/utils/state.ts

[nimble bone]

@winged mantle rate

[winged mantle]

it does io on every call

[nimble bone]

true

do i need to have a state in the state

to store itself

making a class soon

[winged mantle]

why not

• make writing add to a queue of promises
• instead of reading on get, make it read when the file changes asyncrounously

[serene elk]

why does it read on every get instead of using the proxy target

[hoary sluice]

its not the deps

its the docker and raspi

[hoary sluice]

docker and raspi issue

[hoary sluice]

disciplined enough to implement my own llms as to not use deps?

[dense sand]

Its a raspi, what did u expect

[hoary sluice]

exactly this

[placid cape]

wtf

[hoary sluice]

it takes 3 mins cargo clean & release on my laptop and a few secs normally

but it needs to clean build every run in docker

[hoary sluice]

well i expected long times but not 20mins

[hoary sluice]

ok please tell me how to rewrite this without 300 deps https://github.com/eagely/voice-backend/blob/main/Cargo.toml

by 300 im obviously including nested deps, they dont disappear just cause u didnt declare them as deps

[winged mantle]

don't use rust

use java

[hoary sluice]

please tell me how to rewrite this in java with less deps

[winged mantle]

copy all of the deps into your source tree

[fleet cedar]

Vendoring doesn't make you have less deps

It just makes managing them more painful

[hoary sluice]

what exactly does that achieve

[winged mantle]

at least you can say technically you have no deps if you instead plagiarise all of them

[hoary sluice]

besides being a pain to use

[hoary sluice]

it will reduce compile times because you dont need to download deps

[ionic lake]

you could narrow down to just the methods you need but doesn't work all rhe time

[winged mantle]

(don't do this)

[fleet cedar]

Who gives a fuck about cold build time

[hoary sluice]

what does cold mean

[fleet cedar]

After cargo clean

[winged mantle]

i have worked on a 0 dep java project before

[hoary sluice]

oh

[fleet cedar]

(Nevermind that cargo clean doesn't delete download caches)

[winged mantle]

hand rolled json parsing

[hoary sluice]

idc but in docker its always clean

[fleet cedar]

Unless you configure your docker right, yeah

[hoary sluice]

then its more than just clean cause it redownloads

[hoary sluice]

no thanks id rather wait

[winged mantle]

https://github.com/PrismLauncher/PrismLauncher/blob/develop/libraries/launcher/legacy/org/prismlauncher/legacy/utils/Base64.java#L45-L49 i probably have shared this before but :dukethumbup:

[pearl stag]

Base64.java: Lines 45-49

/**
 * Uses Base64 with Java 8 or later, otherwise DatatypeConverter. In the latter
 * case, reflection is used to allow using newer compilers.
 */
public final class Base64 {

[winged mantle]

this was so much fun

[hoary sluice]

and no it wouldnt really work, the recompilation is cause i keep messing up the linking, i have yet to get it to run properly

[winged mantle]

i first tried to write my own base64 implementation

[hoary sluice]

could only get it to run inside debian docker, now i need it on alpine

cant imagine how it was like to use a computer before 2010

[winged mantle]

[hoary sluice]

this raspi wouldve been state of the art in 2010

[winged mantle]

The Unyivewsaw Opewating System

for lesbians

[formal belfry]

you worked on prism?

https://tenor.com/view/cipher-honkai-star-rail-hsr-true-gif-489813417709082854

[ionic lake]

she worked on a prism?

[formal belfry]

she worked on a prism?

[winged mantle]

i am right now

[formal belfry]

how

I will make a launcher in swift one day

[winged mantle]

swiftie launcher

[placid cape]

give me name suggestions for my voice assistant

[fleet cedar]

Jim

[placid cape]

thx

[placid cape]

i have it in python because theres lib for every fucking shit

and i didn't know about porcupine

[crimson sparrow]

I thought the whole point of Rust was to make every project a supply chain attack nightmare

[frosty obsidian]

you're thinking of javascript

[crimson sparrow]

Ah, you’re right

[valid jetty]

there are literally projects for addition and parity in javascript

that many projects use

wait

[crimson sparrow]

:)

[valid jetty]

yeah rust has almost no downloads on those kinds of crates

supply chain attacks cant happen if people arent stupid

as well as, the fact that js has so many fucking packages means ai is very likely to hallucinate js deps, unlike rust which has far less

supply chain attacks are only a nightmare in js land

[placid cape]

yea because people are stupid

and polyfill hell

https://www.npmjs.com/package/is-number

[valid jetty]

yea literally

[placid cape]

93 milion downloads

[royal nymph]

lol criticising js for its dependencies while the average rust project uses 150 crates

[placid cape]

thats true

[valid jetty]

the rust project may use 150 crates but at least rust devs are conservative and dependencies are only so high because people like to share logic if possible

rust devs love to boast about how low their dep count is, unlike js devs who just pnpm i everything lol

[deep mulch]

@valid jetty will Elle have built in is even

@valid jetty elle_modules

make it work identically to npm

[valid jetty]

we have it it’s called %2==0

[deep mulch]

nop too hard

Int.isEven()

[valid jetty]

@hoary sluice’s aoc utils be like

[deep mulch]

yop

eagley uses massive if else tree

up to 1000

[valid jetty]

if i make enough progress elle could genuinely be usable for aoc (i’m not participating anyway)

but i have arrays, iterators, gc, i can add deque and a networking library and stuff

it would genuinely be kinda usable

[royal nymph]

yeah and js devs love to share their is-number logic

what's your point

both use way too many dependencies for random shit

js devs using 150 dependencies: loool lazy js devs just pnpm i anything and have huge supply chain attacks

rust devs using 150 dependencies: actually I am very conservative I just like sharing logic with other highly educated rust developers. rust developers aren't stupid (unlike js devs... ugh) so supply chain attacks can't happen

you're sounding so pretentious lmao

yes those js packages like is-number is-odd etc are laughable and terrible and I wish people would stop using them but

1. no one is denying this fact
2. rust is literally no better in this regard
3. actually most people don't use these packages, it's just that the authors of these libraries have infested the community so much and getting these shitty packages added as indirect dependencies to major packages like express, that's why they're so popular

[winged mantle]

pretentious people write variable names in french

[royal nymph]

re point 3

no one willingly installs is-promise, but when you install express, the most popular http server lib you unknowingly install it

https://npmgraph.js.org/?q=express

it's literally no different in rust lol

no one installs 150 crates

you install 5 crates and those 5 crates pull in 10 other crates that themselves pull in 20 other crates and so on

[winged mantle]

I would argue in rust you often need more direct dependencies because of standard lib lacking things lol

[supple whale]

rookie shit https://npmgraph.js.org/?q=webtorrent

[royal nymph]

without looking at those deps (maybe there's bs deps), torrent is so complex it is probably warranted

[supple whale]

nah

most if is BS

like node-datachannel which uses prebuild install

because it has native code

and that has a gazilion deps

[royal nymph]

i looked and yeah there's a lot of bullshit

[supple whale]

execa is quite a bit of bloat too

rest is all kinda required

[royal nymph]

like any sindre library

sindre is the king of bloat

idk why he has as many sponsors as he does

[supple whale]

first 2 depth shit is all 100% required

actually even first 3 depth

all this is non bloat

the stuff after it is bloat

i maintain all that shit btw

hell, half of it is mine XD

wait wtf that doesnt include the entire tree

yeah it omitted a bunch of deps

bad website

[jade stone]

Is there a way to run this for a local project

[winged mantle]

am I a noob

my other more complicated project has even less

what the hell... another project i checked which is not mine

[placid cape]

why youre not participating in next aoc?

[spark tiger]

this sounds like an extremely fucking dumb question, but uh how would one learn how to actually build sites? like i don't need to learn html or css basics or hundred tags/styles/etc. but rather how to actually make a good site optimized for small screens, mobile and all that stuff

[valid jetty]

school

[winged mantle]

[median root]

well from my limited knowldege, nowadays its picking the new best "cults" of frameworks and libraries to use

id just pick 1 and stick with it

[royal nymph]

optimising for mobile is really not as hard as people make it out to be thanks to media queries

you just gotta learn best practices

[spark tiger]

im gonna stick with jquery

[winged mantle]

https://www.youtube.com/@t3dotgg

[spark tiger]

are media queries like bootstrap and other stuff

[royal nymph]

like using the right units (em/rem is very good)
using the right tools for building layouts (flex and grid, avoid float or magic numbers)

[royal nymph]

😭

media queries are essentially css if statements

[spark tiger]

IM NO WEBDEV

[royal nymph]

if the screen is less than 700px wide, apply this css

[winged mantle]

if you watch all of theo's videos you'll be a webdev genius

[royal nymph]

@media (max-width: 700px) {
}

[spark tiger]

oh i see though sounds like a pita

[median root]

Oh i remember doing something like this in react a few weeks back

[royal nymph]

why?

obviously if you use magic numbers (width: 432px) yeah it's a pain

[spark tiger]

i assume it would probably have like lots of uh cases for @media

i mean for each resolution

[royal nymph]

.my-card-grid {
  --columns: 3;
  display: grid;
  grid-template-columns: repeat(var(--columns), 1fr);
}

@media (max-width: 1000px) {
    .my-card-grid {
        --columns: 2;
    }
}

@media (max-width: 600px) {
    .my-card-grid {
        --columns: 1;
    }
}

simple example

[spark tiger]

rather a vibe coder genius

[winged mantle]

i was husk farming

didn't work

[spark tiger]

lmao

[supple whale]

[spark tiger]

hm alright i'll try that

if it's the easiest way of doing mobile/small screen support

[supple whale]

full async ebml parser btw

[winged mantle]

i wanna see a graph where there is just one thing which depends on itself

[spark tiger]

is tailwind or

[supple whale]

...both

[spark tiger]

also uh remembering the dependencies discussion this chat had half an hour ago would i rather use a dependency for something not-so-hard (like a popup) or just make it yourself

[royal nymph]

this is just one single example how you can make your ui adapt to different screen sizes

[spark tiger]

okay that seems neat

[royal nymph]

build your entire around with stuff like this in mind and always use the right tools (grid, flex)

then it's easy to make it good on smaller sizes

[royal nymph]

full code

<div class="my-card-grid">
    <div class="card">1</div>
    <div class="card">2</div>
    <div class="card">3</div>
    <div class="card">4</div>
    <div class="card">5</div>
    <div class="card">6</div>
    <div class="card">7</div>
    <div class="card">8</div>
    <div class="card">9</div>
</div>

<style>
.my-card-grid {
  --columns: 3;
  display: grid;
  gap: 1em;
  grid-template-columns: repeat(var(--columns), 1fr);
}

.card {
    height: 2em;
    text-align: center;
    background: black;
    color: white;    
}

@media (max-width: 1000px) {
    .my-card-grid {
        --columns: 2;
    }
}

@media (max-width: 600px) {
    .my-card-grid {
        --columns: 1;
    }
}
</style>

[spark tiger]

tjank you (ik what flexbox is)

[royal nymph]

with flex you can do stuff like change the direction the elements flow on mobile

[hoary sluice]

@valid jetty im listening to ferris explain hrtbs

[spark tiger]

was testing friends' site on my iphone and apparently it didn't work because of something in webkit and my friends have no idea how to fix it

[hoary sluice]

i had to install raspi os instead of alpine cause one of the cpp deps i had didnt like musl

[supple whale]

thats not possible

[winged mantle]

it would be cool though

[shrewd canopy]

(because the entire web ecosysten is husk rn)

[spark tiger]

though i'm not entirely sure it's because of webkit but well it works just fine in firefox

[hoary sluice]

you mean

fn foo() {
    foo()
}

[winged mantle]

web dev would be much more fun if it was just gtk

[shrewd canopy]

Yop

[hoary sluice]

the graph is very much possible

[spark tiger]

react + tailwind + shadcn + threejs + chatpgt =

[winged mantle]

why does this code feel so wrong to me why do I prefer (new Error).stack

[hoary sluice]

catch (error) {
    eval(openAi.completion("fix this error, return only code", error))
}

[spark tiger]

and a hardcoded openai token 😍

[winged mantle]

vibe coding

committing .env

[hoary sluice]

@valid jetty how do u even begin to parse that correctly

does new just consume until ) then stop

[winged mantle]

javascript parses things weirdly you need parens around lambda body often

[winged mantle]

consume until non id character?

[spark tiger]

also tryna use astro for my site but it differs so much than just regular html+css+js

[valid jetty]

no i think theres just a special case for constructors

if there is no ( token after the id then it assumes theres no args

which is a fucking weird feature but whatever

[fleet cedar]

It's a really fucking dumb special case, nobody sane would write constructor calls without parens

[spark tiger]

why tf is it still the only way to download a file in web 🥀🥀🥀

[hoary sluice]

theres no way this is real

[spark tiger]

then how else

[hoary sluice]

oh no i believe you

web dev is always stupid so this seems real

[spark tiger]

nah but this one is just extremely fucking dumb idgi at all

[hoary sluice]

like most things in webdev

[valid jetty]

why do you need to add it to the document to click it lol

[spark tiger]

do you not

oh

you mean the appendchild

idk its chatgpt

[valid jetty]

https://github.com/acquitelol/sparxmaths/blob/no-updater/src/core/patches/menu/bookwork/Bookwork.tsx#L70-L77

[pearl stag]

Bookwork.tsx: Lines 70-77

logger.log('Exporting bookwork codes...');
const blob = new Blob([JSON.stringify({ azalea: true, listing })], { type: 'application/json' });
const link = document.createElement('a');

link.href = URL.createObjectURL(blob);
link.download = `azalea.export-${new Date().toLocaleDateString().replace(/\//g, '-')}.json`;

link.click();

[valid jetty]

its not ideal but whatever

[spark tiger]

yeah but still the point is you need to do that goofy .click() that looks so weird

[valid jetty]

somewhat

[spark tiger]

i should stop procrastinating and should start building the site ffs

[valid jetty]

@hoary sluice watch reacher

[supple whale]

may i interest you in streaming downloads from browser

[valid jetty]

im downloading a 100kb json file lmao

streaming that is a little overkill

[supple whale]

what if it was a 100TB?

you never know

[valid jetty]

i dont think it can ever reach even 1mb naturally lol

[supple whale]

ignore the fact that this code is giga old, and i wrote it when i had like a year of experience with JS

well and then you need this....

on the client side

simple

.

[valid jetty]

😭

[supple whale]

its giga great

because then you can do

<video src='/server/fakeFile.js'>

and you can stream a video created in browser

and do the same with images, iframes, audio etc

and you can ofc create streams to download data generated in the browser too via

if (req.destination === 'document') {
  res.headers['Content-Type'] = 'application/octet-stream'
  res.headers['Content-Disposition'] = 'attachment'
  res.body = 'DOWNLOAD'
}

which then lets u do
<a href='./fakefile' target='_blank'>

which will download the file, but as a stream you implement yourself

i love making browsers do shit they arent really made to do

[valid jetty]

why can you use js files as a src for videos

[royal nymph]

he just explained that

[supple whale]

sry

but it can be any extension u want

[valid jetty]

oh i didnt realize that was related

[deep mulch]

@valid jetty omg hiii wyd

didn't see you there >-<

[royal nymph]

?

[deep mulch]

@royal nymph

[winged mantle]

this is the most js code i have seen

[supple whale]

yeah i worte this like 6 years ago?

or 5?

i was giga nub at js

i could write this x10 better now

[winged mantle]

are you a 10x developer

[supple whale]

yes

lol

XD

[valid jetty]

im a 9x developer how about that

[supple whale]

respectable

x4 devs and under arent welcome here

[valid jetty]

@deep mulch

/s

[supple whale]

.

[winged mantle]

what's a pyw

[deep mulch]

a pyw

[winged mantle]

why do i have opera from 2017

@supple whale rate

[supple whale]

could b e worse

i've learned ()=>{} is actually really bad to use, and function () {} should almost always be preferred

[winged mantle]

this is my code from 2016

[supple whale]

yeah but you wrote it in notepad

so like

you didnt have a formatter and shit

[winged mantle]

i don't think i wrote it in notepad

[supple whale]

https://github.com/thaunknown/miru

this is my best code so far

i re-wrote the entire app a few days ago

and this i guess https://github.com/ThaUnknown/video-deband/blob/main/src/main.js

[winged mantle]

using opengl in js

[supple whale]

look closer

its webgl on a VIDEO

XDD

[shrewd canopy]

.py but it doesn't open a console window

[winged mantle]

ah

i guess i wanted it to play an annoying tune with no way to stop it

I find it hard to find any of my 2016 code for some reason lol idk if i barely did any or lost most of it

[supple whale]

i have a lot

i just dont want to admit its mine

my old react code

MMMMMMMMMM

[winged mantle]

https://github.com/TheKodeToad/Spade/tree/v1

so good

[supple whale]

i started writing decent code almost right away cuz i was forced to, i was taught from the start to use eslint, and fix any errors found by it

and boi was it a good way to learn

[winged mantle]

https://github.com/TheKodeToad/Spade/blob/v1/Spade/src/main/java/me/mcblueparrot/spade/mixin/ServerPropertiesHandlerMixin.java#L23-L60 no idea what this is for

[pearl stag]

ServerPropertiesHandlerMixin.java: Lines 23-60

    @Shadow
//    public boolean onlineMode;
//    @Shadow
//    public boolean preventProxyConnections;
//    @Shadow
//    public String serverIp;
//    @Shadow
//    public boolean spawnAnimals;
//    @Shadow
//    public boolean spawnNpcs;
//    @Shadow
//    public boolean pvp;
//    @Shadow
//    public boolean allowFlight;
//    @Shadow
//    public String resourcePack;
//    @Shadow
//    public String resourcePackHash;
//    @Shadow
//    public String resourcePackSha1;
//    @Shadow
//    public String motd;
//    @Shadow
//    public boolean forceGameMode;
//    @Shadow
//    public boolean enforceWhitelist;
//    @Shadow
//    public Difficulty difficulty;
//    @Shadow
//    public GameMode gameMode;
//    @Shadow
//    public String levelName;
//    @Shadow
//    public int serverPort;
//    @Shadow
//    public int maxBuildHeight;
//    @Shadow
//    public Boolean announcePlayerAchievements;

[winged mantle]

horror

so large

[supple whale]

https://github.com/ThaUnknown/miru/blob/master/src/lib/components/ui/player/player.svelte#L2-L24

[pearl stag]

player.svelte: Lines 2-24

import Captions from 'lucide-svelte/icons/captions'
import Cast from 'lucide-svelte/icons/cast'
import ChevronDown from 'lucide-svelte/icons/chevron-down'
import ChevronUp from 'lucide-svelte/icons/chevron-up'
import Contrast from 'lucide-svelte/icons/contrast'
import FastForward from 'lucide-svelte/icons/fast-forward'
import List from 'lucide-svelte/icons/list'
import Maximize from 'lucide-svelte/icons/maximize'
import Minimize from 'lucide-svelte/icons/minimize'
import Pause from 'lucide-svelte/icons/pause'
import PictureInPicture2 from 'lucide-svelte/icons/picture-in-picture-2'
import Proportions from 'lucide-svelte/icons/proportions'
import RefreshCcw from 'lucide-svelte/icons/refresh-ccw'
import Rewind from 'lucide-svelte/icons/rewind'
import RotateCcw from 'lucide-svelte/icons/rotate-ccw'
import RotateCw from 'lucide-svelte/icons/rotate-cw'
import ScreenShare from 'lucide-svelte/icons/screen-share'
import SkipBack from 'lucide-svelte/icons/skip-back'
import SkipForward from 'lucide-svelte/icons/skip-forward'
import Users from 'lucide-svelte/icons/users'
import Volume1 from 'lucide-svelte/icons/volume-1'
import Volume2 from 'lucide-svelte/icons/volume-2'
import VolumeX from 'lucide-svelte/icons/volume-x'

[supple whale]

:^)

[shrewd canopy]

https://github.com/MCausc78/sckema/blob/master/sckema/type.py#L25-L89 more imports

[supple whale]

oh that was only icons sir

https://github.com/ThaUnknown/miru/blob/master/src/lib/components/ui/player/player.svelte#L2-L61

the full imports are way longer

ah o7 @pearl stag

https://github.com/ThaUnknown/miru/blob/master/src/service-worker/index.ts#L1-L9

[pearl stag]

index.ts: Lines 1-9

import { clientsClaim, skipWaiting } from 'workbox-core'
import { cleanupOutdatedCaches, precacheAndRoute } from 'workbox-precaching'

import { build, files, prerendered, version } from '$service-worker'

precacheAndRoute([...build, ...files.filter(e => !['/Ameku.webm', '/video.mkv'].includes(e)), ...prerendered, '/'].map(url => ({ url, revision: version })))
cleanupOutdatedCaches()
clientsClaim()
skipWaiting()

[supple whale]

this tho

i fucking love sveltekit

4 loc for automatic updating offline cache

[winged mantle]

has support for groovy plugins https://github.com/TheKodeToad/Spade/blob/v1/Spade/src/main/java/me/mcblueparrot/spade/SpadePluginManager.java#L140-L175

[pearl stag]

SpadePluginManager.java: Lines 140-175

else if(pluginFile.isDirectory() && pluginFile.getName().endsWith(".plugin")) {
    try {
        File descriptionFile = new File(pluginFile, "plugin." + ConfigurationSystem.getDefault().getExtension());
        Configuration description;
        String scriptName;
        try {
            description = ConfigurationSystem.getDefault().load(descriptionFile);
            scriptName = description.getString("script");
            Objects.requireNonNull(scriptName);
            Objects.requireNonNull(description.getString("name"));
            Objects.requireNonNull(description.getString("version"));
        }
        catch(Throwable e) {
            logger.error("Invalid plugin description");
            throw e;
        }
        if(scriptName.equals("plugin") || scriptName.equals("server") || scriptName.equals("scheduler") || scriptName.equals("pluginManager")) {
            throw new IllegalArgumentException("Script cannot be called plugin, server, scheduler or pluginManager");
        }
        File scriptFile = new File(pluginFile, scriptName + ".groovy");
        if(!scriptFile.exists()) {
            throw new FileNotFoundException("Cannot find script " + scriptFile.getName());
        }
        ScriptPlugin plugin = new ScriptPlugin(scriptFile);
        plugin.setDescription(description);
        Binding binding = new Binding();
        binding.setProperty("plugin", plugin);
        binding.setProperty("server", Spade.getServer());
        binding.setProperty("scheduler", Spade.getScheduler());
        binding.setProperty("pluginManager", this);
        GroovyShell shell = new GroovyShell(Launch.classLoader);
        Script script = shell.parse(scriptFile);
        script.setBinding(binding);
        script.run();
        plugins.add(plugin);
    }

[winged mantle]

[winged mantle]

what's a recommended way to stop path traversal in node.js 😭

when i search i can only find stuff like normalising and checking whether it starts with .. (which isn't the best)

[shrewd canopy]

validate user input lol

[winged mantle]

yeah but how?

[shrewd canopy]

then where you are trying to prevent path traversal

[winged mantle]

i am trying to join a path to a root dir

and throw an error if it goes outside the dir

I don't want to do something myself because there might be an oversight

[supple whale]

there's a lot of ways

like a LOT LOT

start with a path.resolve

so path.resolve(base, userinput)

that gives u a normalized path

then you can check that normalized path

[winged mantle]

i noticed that a lib which did something like that had to change it due to a vuln

their solution now is regex

ig that's fine

[supple whale]

for example if(path.relative(base, normalized).startsWith('..')) throw new Error('Nuh-uh')

there are probs better ways of doing it

[winged mantle]

that also matches paths like ..test, no?

[supple whale]

well that checks if some1 tries to exit base

if they are, wont let them

[winged mantle]

i would rather use something battle tested but for example the impl that express uses feels quite complex

[supple whale]

yeah

that sounds about right

UP_PATH_REGEXP is probably a check for ^../

so its legit what i sent u

path.normalize instead of path.resolve

so i got braincells on me after all

[winged mantle]

checking for .. will break for paths like this

[supple whale]

do ^../

[supple whale]

.

[winged mantle]

ohh I now understand that vuln with express's dep

it just allowed you to work out the root path name from seeing if you got an error

what even is the point though

this is just startsWith

maybe old js didn't have

implementation i ended with

you're right resolve does normalize... at least if i understand node source code correctly

[winged mantle]

@valid jetty you love

why just have else if when you can have else for

[median root]

ok why are these stupid font files so hard to work with

ive just spent 20mins tryna figure out why my icons were in the wrong place just to find out there like 3 diffrent kinds of .ttf file

and im meant to know that

[median root]

same extensions too

[fleet cedar]

Most older languages don't even have else if

It's just else any-statement

Yes

That's exactly what I just said

if is a statement, {} is a statement

[winged mantle]

for some reason it didn't occur to me

[hoary sluice]

@placid cape i got silence detection to work exactly 20 mins before i have to leave to present it

[placid cape]

Lol

[hoary sluice]

it was supposed to be on alpine & kde but one of my deps (whisper-rs) assumes u have glibc and im not smart enough to make it work

and alpine uses musl

[placid cape]

oh yea

[hoary sluice]

but i dont think my supervisor knows what a linux distro is so its fine

[hoary sluice]

@valid jetty portal 2 is turing complete

[royal nymph]

I prefer for if

for (const value of arg.value) if (value != null) {
    yield value;
}

[winged mantle]

value is not even nullable

[royal nymph]

🤫 just an example

[hoary sluice]

is this just sugar for a filter

[winged mantle]

for (const value of arg.value)
if (value != null)
yield value;

better

[abstract sentinel]

hey are there some docs or relevant info about plugin development? /getting started?

[median root]

theres the source code and reading other plugins

thats what taught me most about this

[abstract sentinel]

figured since i couldnt find anything just thought i might as well ask

[median root]

I mean last I checked I didnt really find any extensive documentation on this

[supple whale]

thats low key kinda cool

[median root]

yo is anyone elses new "stable" flutter version flashing black on the screen every 0.7 seconds?

ive had to downgrade back to 3.29.3

[median root]

I might just sit on this version until some new "magical" exploit that spesifically targets old flutter versions comes out then

[hoary sluice]

@valid jetty these would be builtins

but this isnt really maintainable imo

if theres more than 1 arg it gets annoying to write

[valid jetty]

make a macro for it

[hoary sluice]

thats my goal

but last time i tried i miserably failed

i need to watch some kinda macro tutorial

[valid jetty]

btw you can make the a def cleaner

[hoary sluice]

arg.ok_or right

[valid jetty]

let Value::Integer(a) = arg else {
    return err!();
}

[hoary sluice]

oh

right yea

you taught me that like a week ago

[valid jetty]

lmao

also i think rust should be able to infer the types of arg2 and loc2 because its being assigned directly to the function field

but dont quote me on that

[hoary sluice]

yes it can

i think this is called a tt muncher

[valid jetty]

yes

[placid cape]

@hoary sluice what do you use for mic, speakers for the rpi?

[hoary sluice]

a usb headset for testing and a usb mic and aux headset (or vice versa i dont remember) for prod

[placid cape]

which usb mic

[hoary sluice]

some random one from amazon

[placid cape]

im trying to make https://wiki.seeedstudio.com/respeaker_2_mics_pi_hat_raspberry_v2/ this shit working

but of course it doesnt work

[hoary sluice]

ik raspi is garbage to work with

i wrote the software perfectly fine and then took a long time to get the raspi set up

and i had no hardware besides a usb headset

[deep mulch]

@hoary sluice

[placid cape]

yea

i hate it

so much

AAAAAAAAAAAAAAAAAA

[spark tiger]

https://docs.vencord.dev/plugins/
https://gist.github.com/sunnniee/28bd595f8c07992f6d03289911289ba8

[median root]

well this woulda been useful about 2 years ago

Oh yes I love how it dont tell me how to get one of these native.ts files

[fleet cedar]

touch native.ts, same as any other file

[glacial mirage]

it says

files you can create
so you have to make it yourself

[spark tiger]

stop spreading misinformation 😡

'touch' is not recognized as an internal or external command, operable program or batch file.

[fleet cedar]

Yeah but like on sensible OSes I mean

[glacial mirage]

just open a text editor and save to that file location then

[median root]

is there no boilerplate surrounding it where I have to like tell the browser i have a native file?

[glacial mirage]

its just based on the name i think

[median root]

well what else would I expect from javascript i guess

yeah like this thing:

const Native = VencordNative.pluginHelpers.RandomGary as PluginNative<typeof import("./native")>;

do I not need to do this?

[median root]

ooh great so I just do this but replace RandomGary with the plugin name and everything should in theory work

import definePlugin, { PluginNative } from "@utils/types";
const Native = VencordNative.pluginHelpers.${pluginName} as PluginNative<typeof import("./native")>;
Native.method()

something like that I think

eh ill try it later

[fleet cedar]

Well the browser won't give a fuck about natives

Only electron does

[median root]

and why does electron care?

[fleet cedar]

Because electron's literal purpose is frankensteining browser and native

[median root]

augh I wish we could like not-sandbox

[fleet cedar]

You won't wish that anymore after your first 0day

[valid jetty]

lmao no way 😭😭😭

[hoary sluice]

@valid jetty 135 xp from 1 lesson

[fleet cedar]

Well are you?

[hoary sluice]

Nop, I'm a supercomputer, it's time to finally just admit it.

[valid jetty]

@hoary sluice @deep mulch

[deep mulch]

it wont play

[valid jetty]

i don’t think you want it to play

[hoary sluice]

wrong

every language ever calls it film

[valid jetty]

are you just not seeing the video or like

[placid cape]

How did you get 135 xp

What's your name on Duolingo

[hoary sluice]

meh its not that creative

[hoary sluice]

theres triple xp boosts now

[hoary sluice]

eagelyxd

[placid cape]

i sent you request

[hoary sluice]

@valid jetty

no macro for it yet but it works

[valid jetty]

yay

[hoary sluice]

i spent a solid 10 minutes trying to figure out why it couldnt resolve the identifier

turns out i named the function println cause i thought i was smart

and then proceeded to call print in the icy code

theres only o

no i

but now i have more or less of a week of free time

so maybe i soon

oo

also

print "hi"
``` evaluates to "hi"

[valid jetty]

so its like dbg in rust?

[hoary sluice]

so u can do

print 2 + 3

and itll print 2 and evaluate to 5

again its println not print

i forgot again

[valid jetty]

that is so ambigious lmao

[hoary sluice]

dbg does that???

[hoary sluice]

how

its parsed as Binary(+, Call(print, 2), 3)

[valid jetty]

yes lol you can do let x = dbg!(funcall()) and the result of x is the result of funcall()

[hoary sluice]

function application has the highest precedence

[hoary sluice]

oh i didnt know that

[valid jetty]

if you pass more args the result is a tuple of the args you passed in

[hoary sluice]

cursed tuple factory

so println 2 + 3 isnt ambiguous at all

[valid jetty]

[valid jetty]

i wouldve expected it to print 5

[hoary sluice]

nop

u shouldnt expect that

[valid jetty]

are you trying to gaslight me or are you trying to gaslight yourself that its better this way

[hoary sluice]

its how haskell does it lol

[valid jetty]

husk

[hoary sluice]

and it makes more sense

print 2 + 3 isnt valid in haskell cause print doesnt return (or like world monad stuff) but f x + y is (f x) + y

[valid jetty]

not exactly because you cant even do that in haskell

[hoary sluice]

i mean this is probably real because i got an sms from them when signing up but also i dont have any money in my bitpanda

[hoary sluice]

you can if print is id

id 2 + 3 evaluates to 5

[valid jetty]

you cant print 2 + 3 tho lol

[hoary sluice]

yea like i said, print returns the world monad

[valid jetty]

you can do this i guess

main :: IO ()
main = putStr $ show (2 + 3)

[valid jetty]

hm

[hoary sluice]

for me print is the identity function

in haskell it isnt

[valid jetty]

oh i see what you mean

i guess you cant really call this language purely functional

[hoary sluice]

well ok how do u make io purely functional

you cant

[valid jetty]

thats a solved problem 😭 you return a new state of the World

[hoary sluice]

returning world monad is a stupid workaround based on technicalities

[valid jetty]

lmao

[hoary sluice]

id rather rosie tell me icy isnt purely functional than make it bad

[valid jetty]

day 542 of telling you you couldve just made it procedural and all your problems dissapear

but tbf procedural is slower to write

[hoary sluice]

my problems are quickly fading away

and i already made a procedural interpreter

be it not very featureful

[valid jetty]

purely functional compiler soon

[hoary sluice]

now i just need input, macros for io, make it compiled () and i can rewrite icy in icy

[valid jetty]

(even i dont know how i would approach that)

[hoary sluice]

compile to haskell

[valid jetty]

isnt that cheating

[hoary sluice]

aka print(open(0).read())

[valid jetty]

😭

do you have $

[hoary sluice]

yes but not the same as in haskell

its the . in lambdas

soon itll get usable enough to where i have to make a readme and docs and an lsp and all that stuff

[valid jetty]

is the end goal here to have a situation like vlang

for vlang the primary compilation target is C

[hoary sluice]

whats vlang

[valid jetty]

https://vlang.io/

[hoary sluice]

no the goal is an interpreter

i wanna try to get this workable before aoc

[deep mulch]

@valid jetty hii

v lang is funny

[hoary sluice]

enough for me to be able to solve every aoc day without having to add extra features during aoc

[deep mulch]

I played around with it before

[valid jetty]

i said end goal

[hoary sluice]

idk if i wanna compile

[deep mulch]

Elle will compile to JS

[valid jetty]

but compilers so fun :(((

[deep mulch]

@valid jetty make Elle compile to Java

[valid jetty]

its possible

i could genuinely do it

[hoary sluice]

im starting uni in september so there might be some other stuff ill be doing

[deep mulch]

@hoary sluice I thought you were already in uni

[hoary sluice]

i am technically

i finished school in april, doing matura exams now (final exams at the end of high school standardized in europe) and im accepted to the uni, in their cis system, and paid a deposit

and im starting in 3rd semester

so im technically in the 2nd semester rn

tho not actually doing any studying

[valid jetty]

@deep mulch

its possible

[deep mulch]

insanity

[hoary sluice]

js always longer than elle

compile elle to wasm

does qbe target wasm

prob not right

switch to llvm

qbe is limited

rewrite elle in elle on llvm

[valid jetty]

i dont want my compilation times to quadruple thank you

[hoary sluice]

the earlier you start the better

[pseudo sierra]

make your own compiler backend in elle

[hoary sluice]

youre literally using rust and your compilation times are extremely fast why do u care

[valid jetty]

no i meant

compiling the llvm ir to assembly

do you know how slow it is

[hoary sluice]

your compilation times are already extremely fast so quadrupling them wont hurt

and youre using rust and complaining abt compile times

[deep mulch]

@valid jetty make Elle os

that would be fun I bet

[hoary sluice]

https://www.youtube.com/@kiahjh-dev

this guy is making a compiled functional language to then make an OS in

[deep mulch]

I wanna do that

[valid jetty]

rust isnt related here, the part im talking about is not elle itself but is the process of translating IR to assembly

qbe is very fast, llvm is not so much

[hoary sluice]

https://www.youtube.com/@kiahjh-dev/streams

[deep mulch]

make Elle faster than C@valid jetty

[hoary sluice]

if its 4x slower itll still be fast

[hoary sluice]

but your desensitized to slow compile times due to your rust

statically linking everything and duplicating every dependency is extremely based

[valid jetty]

i mean not as fast anymore lol, since i added all that monomorphization and extra passes and stuff

[deep mulch]

does Elle have tree shaking

where you shake a tree

[valid jetty]

kind of

[hoary sluice]

@deep mulch can i shake your tree

[valid jetty]

this wont go down well, itll probably be kinda slow

[deep mulch]

yea

[valid jetty]

i think the best way to go is genuinely to make a C compilation target

C can compile to almost anything

[deep mulch]

@young flicker

[deep mulch]

can it compile to Elle

guhh just make Elle support npm modules

[valid jetty]

girl im sorry to scare you

[hoary sluice]

???

[valid jetty]

but i think its defined

[deep mulch]

add 500 keywords @valid jetty

@valid jetty add keyword to use registers directly

[valid jetty]

why

[deep mulch]

funny!!!

@young flicker @young flicker @young flicker

[hoary sluice]

@valid jetty write elle using only rust macros

easiest way to compile to rust

literally built into rust

@deep mulch 100 gorillas vs the sun?

[nimble bone]

write elle in elle @valid jetty

[hoary sluice]

@deep mulch 100 humans vs 1 human?

who would win

@deep mulch 1 rosie vs 1 zooter?

[deep mulch]

Rosie loses

I could destroy Rosie easily

[valid jetty]

@hoary sluice i found another edge case to the monomorphization system earlier

[hoary sluice]

why have you been working on monomormonism for the last 6 years

[valid jetty]

use std/prelude;

struct Foo<T> {
    Option<fn(T) -> T> cb
}

fn main() {
    Foo<i32> foo = Foo {
        cb = Option::Some(fn(x) x * 2)
    };

    x := foo.cb.unwrap();
    $dbg(x(34));
}
``` when the callback is wrapped in another function call

during monomorphization, `Option::Some()` accepts a T, not a function type

even though it can be inferred that `x` is `i32` because `cb` accepts a `Option<T>` where T is a function, the compiler doesnt know that when monomorphizing the function call to Option::Some and as such cant infer the type of `x`

[valid jetty]

ITS HELL

there are so many edge cases

its going through like 3 steps of monomorphization here

[hoary sluice]

im glad i wont have to mormonize

why any time i search for anything related to compilers, the first result is almost always from a rust / book / forum / other rust-related source

is rust really just used to make compilers and memecoins

[valid jetty]

• Foo<T> links T to fn(T) -> T
• Foo<i32> means that cb's type isOption<fn(i32) -> i32>
• that type is passed to use in Option::Some to infer T (from the return type, Option<T> vs Option<fn(i32) -> i32>)
• when deducing a type from fn(x) x * 2, we dont yet know what T (from Option::Some<T>) is, so x cant be inferred
• i need to do like 4 passes for codegen to properly monomorphize this
• suffering.

[valid jetty]

yes

[valid jetty]

its a super fun exercise (i say, with tears rolling down my face)

i could take the lazy way out

and make it so that, if the arg is exactly T and we know T then use a different param ty to monomorphize the lambda with

but that breaks when it becomes

fn foo<T>(Bar<T> x) -> Foo<T>

struct A<T> {
    Foo<fn(i32) -> i32> cb;
}

fn main() {
    A<i32> a = A {
        cb = foo(bar(fn(x) x * 2))
    };
}

because its Bar<T> x not T x

omg wait

[hoary sluice]

i dont understand any of this

[valid jetty]

YES

😭

[valid jetty]

ignore the logic just know that this is to infer the types of args in lambdas where youre comparing an unknown type to a lambda

[hoary sluice]

im glad i dont care about speed

[valid jetty]

uhhh you should probably start caring

or youll take 2 years to get your solves

[hoary sluice]

you used python and beat me

aoc is about writing a good algo not having a fast language

to get on global lb you have to beat the bruteforcers

if you just try bruteforcing you wont win cause thats easy and a lot of ppl do it so theres a lot of competition

[valid jetty]

i mean yeah good point

but there are some cases where it just takes a while

[hoary sluice]

well python is also incredibly slow for no reason

[valid jetty]

..there is a good reason

its called ✨ an interpreter ✨

[hoary sluice]

but its like

slow even for an interpreter

[valid jetty]

i mean from what ive heard its actually way faster these days than it used to be

but still doesnt compare to a compiled language

[hoary sluice]

well ofc

[valid jetty]

excuse me

oh i see

im not actually sure how to deal with that

[hoary sluice]

how are ur errors so awesome

[valid jetty]

spaghetti code

[hoary sluice]

what

no like the error msgs

[valid jetty]

the key to a good error display is spaghetti code

[hoary sluice]

almost as good as rust

[fleet cedar]

Delicious spaghetti makes the error gremlins happy

[valid jetty]

true

beautiful isnt it

[hoary sluice]

when are u gonna refactor elle

[valid jetty]

already did for the compiler

idk about the rest

[hoary sluice]

rewrite it in elle

[valid jetty]

RIIE

[valid jetty]

ok i figured out whats actually happening

to make the inference in lambdas work, i deduce generics from the return type before function arguments

which means it learns T = Result<T, E> but doesnt know anything else yet

then it compiles the Result::Ok(...) and learns that T = Result<...> but it already learnt that T = Result<T, E>

idk if i should allow arbitrary conversions from generic to non-generic structs

i have an ideaaaaa

[hoary sluice]

how

do u use zed dbg

[valid jetty]

no lol

i just examined the control flow of my program

[hoary sluice]

why not

[valid jetty]

whats zed dbg

[hoary sluice]

the new zed debugger

[valid jetty]

isnt that ai powered or something

[hoary sluice]

no its codelldb in a fancy panel

[valid jetty]

lmao

ok ill look at it

[hoary sluice]

and theres ai agents too

its invite only beta but they invite everyone but u have to wait

[valid jetty]

the fact that it is able to infer EVERYTHING here is kinda insane

[valid jetty]

oh i remember that email

i already got my invite

nvm

its not an invite

its just the launch post

[hoary sluice]

rosie my job suddenly decided to require windows with no admin and supervision

[valid jetty]

qemu with gpu passthrough

[hoary sluice]

u cant install apps

[valid jetty]

what i did is, i still infer the return type generics but now i dont just directly populate known_generics with them

[hoary sluice]

only through baramudi

[valid jetty]

i keep them seperate until after args are deduced, then i add them if there are still unknown generics

wtf is baramudi

[hoary sluice]

exactly

nah its some kinda enterprise confidentiality management software

[valid jetty]

[hoary sluice]

but wsl is allowed

im gonna try nixos-wsl

it probably wont work

[valid jetty]

😭

[valid jetty]

whats a neat way to format this 😭

server, port := TcpServer::bind_until(
    8080,
    fn(server) server.is_ok_or(fn(err) err != Errno::EADDRINUSE),
    Option::Some(fn(port) { *port += 1; })
).expect("Failed to bind server");

[shrewd canopy]

maybe don't introduce bind_until and just let user do it manually?

[valid jetty]

true

ehhh thats not that bad

server := TcpServer::bind(port := 8080);

while server.is_err_and(fn(err) err == Errno::EADDRINUSE) {
    server = TcpServer::bind(port += 1);
}

clean overall i think

use std/prelude;
use std/net/tcp;

const BUF_SIZE = 1024;

fn main() {
    server := TcpServer::bind(port := 8080);

    while server.is_err_and(fn(err) err == Errno::EADDRINUSE) {
        server = TcpServer::bind(port += 1);
    }

    server := server.unwrap();
    defer server.close().unwrap();
    $printf("Server is listening on port {}", port);

    buf := Array::bytes(BUF_SIZE);
    connection := server.accept().unwrap();
    defer connection.close().unwrap();

    while (_, received := connection.read(buf)) && received != 0 {
        $printf("Received {} bytes: {}", received, buf.join("").replace("\n", ""));
        connection.write(buf).expect("Failed to send response");
    }
}

@hoary sluice is this a clean api

use std/collections/array;
global pub;

pub struct Foo {
    i32 x,
    string y,
    f64 z,
}

fn Foo::to_bytes(Foo self) -> u8[] {
    res := [];

    res.extend([self.x].to_bytes());
    res.extend([self.y.len()].to_bytes());
    res.extend(Array::from_string(self.y).to_bytes());
    res.extend([self.z].to_bytes());

    return res;
}

fn Foo::from_bytes(u8[] res) {
    self := #alloc(Foo);
    offset := 0;

    self.x = res.read<i32>(&offset);
    len := res.read<u64>(&offset);
    self.y = res.slice(offset, offset += len).to_repr<char>().join("");
    self.z = res.read<f64>(&offset);

    return *self;
}

so you can go back and forth

foo := Foo { x = 39, y = "Hello from the server", z = 4.2 };
$printf("Sending {}", foo);
connection.write(foo.to_bytes()).unwrap();

buf := Array::bytes(BUF_SIZE);
client.read(buf).unwrap();
foo := Foo::from_bytes(buf);
$printf("Received {}", foo);

[valid jetty]

@hoary sluice 😭

[calm wigeon]

this is horrid

[dense sand]

What a combo

[blazing haven]

"quick start"

more like

quick bloat

[shrewd canopy]

Remove npm and its good

[deep mulch]

elle install is_even

[deep mulch]

@valid jetty if you ever need ideas for Elle just ask me

[fleet cedar]

But what if she needs good ideas

[deep mulch]

I have all goodideas

[hoary sluice]

@valid jetty tsoding v2 https://www.youtube.com/live/MUDz4_HkgeA?si=AdbpjW2TiwJvkWgK

[hoary sluice]

then she can ask me

rewriting elle in elle is a good idea

[hoary sluice]

@valid jetty his nvim setup looks too good im gonna keep working on my rice today

[valid jetty]

minklang

[valid jetty]

interesting

[deep mulch]

how

[valid jetty]

# add :: fun (~x: Int, to y: Int) -> Int: x + y

# main :: fun () -> Int: {
  # x :: 4
  # y :: add(x, to: 3)
  # y
# }

x :: {}

interesting syntax

oh my god he’s writing a borrow checker

[hoary sluice]

2 names for args

one for the function body one for the caller

[valid jetty]

yea i know there’s quite a few languages that do this

namely swift and objc

there are definitely more

@hoary sluice

i genuinely cannot tell whether this is real or ai

like

[deep mulch]

@valid jetty is an ai

AI cannot tell AI from real

weird

page doesn't work through cloudflare

404 for one of the required files

[hoary sluice]

nah thats not ai

never

[valid jetty]

but the conversation is so lifeless

and the knives are magnetic to the wall???

[royal nymph]

https://www.wmf.com/de/en/magnetic-knife-rack-3201002956.html

[hoary sluice]

ai convos arent lifeless

[hoary sluice]

theres a magnetic bar lol

[shrewd canopy]

Is that nohtyP

[valid jetty]

@hoary sluice thunks come for free

use std/prelude;

namespace Cat;
fn Cat::speak(Cat *self) {
    $println("*mew*");
}

namespace Dog;
fn Dog::speak(Dog *self) {
    $println("*wof*");
}

struct AnythingSpeak @nofmt {
    void *data,
    fn(void *) speak_thunk
}

fn AnythingSpeak::new<T>(T *t) {
    return AnythingSpeak {
        data = #cast(void *, t),
        speak_thunk = fn(data) #cast(T *, data).speak()
    };
}

fn AnythingSpeak::speak(AnythingSpeak self) {
    cb := self.speak_thunk;
    cb(self.data);
}

fn main() {
    a := AnythingSpeak::new(&Cat {});
    a.speak();
    a = AnythingSpeak::new(&Dog {});
    a.speak();
}

[hoary sluice]

how are these thunks

[fleet cedar]

There's a billion definitions of thunk, I'm sure it's one of them

[hoary sluice]

my understanding of thunk is its a wrapper for a value that tells the interpreter not to evaluate that value until its used

[valid jetty]

that is a different kind of thunk

thunks in compiled languages are type-erased values

things like &dyn Speak in rust

or a virtual method in C++

[hoary sluice]

oh

[hoary sluice]

this is horror to read and write tho

[valid jetty]

well yeah obviously

[hoary sluice]

its free but it also looks free

[valid jetty]

wellll