09:17 <discocaml> <froyo> @dumbpotato : someone compiled stackoverflow developer survey answers and apparently the lang with largest % is apl

09:28 <discocaml> <froyo> ok I just checked again, it wasn't the biggest lgbtq %, just the biggest trans %, but it's probably indicative.

09:28 <discocaml> <froyo> first place APL at 12%

09:28 <discocaml> <froyo> second crystal and third ocaml apparently

09:28 <discocaml> <froyo> :D

09:29 <discocaml> <froyo> at 7%, beating cl and haskell and lua by the double

09:31 <discocaml> <froyo> (rust is even lower, 11th place)

10:58 <greenbagels> apl huh

10:59 <greenbagels> didnt even realize people still used apl

11:01 <leah2> haha

11:09 <discocaml> <commutativeconjecture> interested in where i should dump feedback that i get from beginners trying to learn ocaml. stuff like: `opam` and `dune` not being bundled together, the lack of good documentation for local opam switches and opam lock files (and them being not recommended by default!), `dune` using s-expr instead of yaml, etc.

11:11 <discocaml> <commutativeconjecture> interested in where i should dump feedback that i get from beginners trying to learn ocaml. stuff like: `opam` and `dune` not being bundled together, the lack of good documentation for local opam switches and opam lock files (and them not being recommended by default!), `dune` using s-expr instead of yaml, etc.

11:43 <greenbagels> I find the yaml feedback to be interesting

11:43 <greenbagels> I feel like if someone is in the programming scene enough to understand yaml then learning the dune syntax shouldn't be so weird

12:23 <discocaml> <commutativeconjecture> there's a finite weirdness budget, all things that eat weirdness eat into that budget. most config files have moved toward json and many are moving to yaml/toml

12:23 <discocaml> <commutativeconjecture> better imho to use that weirdness budget on things that are actually relevant / intrinsic complexity, rather than "[X] isn't that weird"

12:24 <discocaml> <commutativeconjecture> also, many ppl i try to move to ocaml used js/ts, python, c/c++ in the pasdt

12:24 <discocaml> <commutativeconjecture> also, many ppl i try to move to ocaml used js/ts, python, c/c++ in the past

12:25 <discocaml> <commutativeconjecture> not prog newbies

12:27 <discocaml> <darrenldl> what does c/c++ use as config?

12:27 <discocaml> <commutativeconjecture> not sure how (non-)representative i am, but in my experience, ocaml is a good general prog lang, and there's a lot of "wooo ocaml is an arcane academic french functional prog lang", and reducing the weirdness helps a lot

12:28 <discocaml> <commutativeconjecture> makefile/cmake iirc, been a while since i personally did

12:28 <discocaml> <commutativeconjecture> not sure how (non-)representative i am, but in my experience, ocaml is a good general prog lang. but there's a lot of "wooo ocaml is an arcane academic french functional prog lang", and reducing the weirdness helps a lot

13:11 <discocaml> <froyo> yeah cmake hell

13:13 <discocaml> <contificate> the gold standard for any build system is to avoid the general review: "it's painful to use, but then it just works"

13:13 <discocaml> <contificate> as then absolute disasters like cmake stick

13:13 <discocaml> <froyo> greenbagels, interestingly the person who compiled the data also pointed out that the largest intersection between trans programmers and those who use one language only is also in apl

13:13 <discocaml> <froyo> second being python

13:14 <discocaml> <froyo> so it's not just in use, people seem to be using it exclusively

13:17 <discocaml> <froyo> would be nice to have a wiki site hosted on ocaml.org and community-source beginner grievances and their solutions in one big page

13:19 <discocaml> <froyo> syntax weirdnesses, value vs unitary function, modules vs fcms, comparison operator shadowing, the role of ;; ...

13:19 <discocaml> <froyo> those at the top of my head

13:20 <discocaml> <froyo> the meaning of 'a in a type signature and the subtle differences between that and universal variables

13:21 <discocaml> <bluddy5> ocamlverse.org was kinda built for that kind of thing

13:21 <discocaml> <froyo> i say weirdness but rather false expectations

13:21 <discocaml> <bluddy5> sorry ocamlverse.net

13:25 <discocaml> <commutativeconjecture> @bluddy5 which page from ocamlverse do you have in mind?

13:37 <discocaml> <bluddy5> see pages like https://ocamlverse.net/content/faq.html

13:38 <discocaml> <bluddy5> But you're free to contribute more pages. It's a community wiki.

14:07 <companion_cube> Dune using sexprs instead of yaml is a blessing, tbh

14:11 <discocaml> <gabyfle> I was wondering, the OCaml virtual machine is coded in C ?

14:12 <discocaml> <gabyfle> When I'm looking at the `OCaml` github repository, I saw this runtime folder: https://github.com/ocaml/ocaml/tree/trunk/runtime

14:43 <discocaml> <bluddy5> The runtime is written in C, yes.

14:44 <discocaml> <bluddy5> The bytecode's runtime is closer to a virtual machine.

14:49 <companion_cube> There's a runtime in C, yes (with IO primitives, the gc, etc) but your code is typically compiled to native

16:06 <discocaml> <gabyfle> What's the advantage of writing the runtime in C rather than using OCaml itself to write it ?

16:18 <discocaml> <bluddy5> The runtime needs to be extremely efficient.

16:19 <discocaml> <bluddy5> It also needs low-level access to memory.

16:19 <discocaml> <contificate> You would also eventually need to appeal to system calls (at the very minimum) anyway, even if you did try to implement the runtime in OCaml itself. There's always a part that must actually deal with the operating system.

16:20 <discocaml> <.armael.> it wouldn’t even be possible, the runtime provides the memory allocator, garbage collector

16:20 <discocaml> <.armael.> Which ocaml code assumes already exists

16:22 <discocaml> <darrenldl> re yaml: id like to think i have had more confusion with yaml than s-exprs. and parsing yaml in native ocaml needs a lot of effort that no one has done yet i think

16:25 <discocaml> <gabyfle> Would it be possible theoretically to rewrite the OCaml runtime so that its written 100% ? Like for example, rewriting the garbage collector using OCaml

16:25 <discocaml> <gabyfle> Would it be possible theoretically to rewrite the OCaml runtime so that its written 100% in OCaml ? Like for example, rewriting the garbage collector using OCaml

16:26 <discocaml> <contificate> You could make more of it OCaml, definitely. There's no good reason to though.

16:29 <discocaml> <.armael.> It would make more sense to rewrite it in rust, which is a good language for this kind of code

16:29 <discocaml> <contificate> You can imagine languages that would support a kind of awkward runtime bootstrapping process, if designed that way from the beginning.

16:30 <discocaml> <.armael.> (But the distribution / toolchain aspect would probably be cumbersome)

17:19 <discocaml> <commutativeconjecture> companion_cube: "Dune using sexprs instead of yaml is a blessing, tbh" -> why?

17:21 <companion_cube> Because yaml is terrible to parse and to write, sexprs are simpler and more robust

17:22 <discocaml> <commutativeconjecture> i expect config files are much much more often read and edited than written-a-parser-for

17:22 <discocaml> <contificate> why is yaml center stage when toml seems nicer than yaml

17:23 <discocaml> <commutativeconjecture> but to be fair, i don't care much for _improving ocaml in some ways_, and much more about _documenting why ocaml shall not be improved in those ways_

18:08 <discocaml> <functionalprogramming> yaml has too many features

19:18 <discocaml> <commutativeconjecture> i have 0 shares in yaml, and don't care for yaml vs toml vs json vs sexpr vs xml

19:18 <discocaml> <commutativeconjecture> yaml having too many features seems largely independent to the point that i was raising: which was that many ppl used to some type of config files (around js and python) find s-exprs to be a hurdle

19:18 <discocaml> <commutativeconjecture> i have 0 shares in yaml.inc, and don't care for yaml vs toml vs json vs sexpr vs xml

19:19 <discocaml> <commutativeconjecture> yaml having too many features seems largely independent to the point that i was raising: which was that many ppl used to some type of config files (around js and python) find s-exprs to be a hurdle

19:36 <discocaml> <rgrinberg> not having a spec complaint yaml parser written in OCaml is a hurdle to use it in an OCaml build system don't you think?

19:53 <dh`> why would you _want_ to use yaml? sheesh

19:53 <dh`> not that generic s-expressions are better

20:38 <discocaml> <contificate> I wouldn't say it's a hurdle, technically - at first glance at many weird config languages, I'd be tempted to use a tried and tested MIT licensed tiny C impl via bindings than a homegrown pure OCaml effort

20:39 <discocaml> <contificate> the syntax of dune files is a surface level concern, I've never felt inconvenienced by S-expressions

21:31 <discocaml> <deepspacejohn> The only times I’ve disliked dune files is when I’ve wanted to write a script that can parse them or generate them etc. Every language has a library that can parse json/yaml/toml.

21:45 <olle> Hmmm a sum type constructor is not first-class in a match clause right?

21:45 <olle> match x with | A x -> ... | B x -> ...

21:45 <olle> But make A and B interchangeable

21:50 <olle> Like `T x` instead of `A x | B x`

21:51 <discocaml> <._null._> You can't have things like `if b then A else B` as a pattern no

21:52 <olle> Hm

22:11 <greenbagels> maybe im weird but when i started learning ocaml i didnt even bother trying to mess with build systems

22:12 <greenbagels> and when i did, it was just for very simple programs and i just used ocamlbuild

22:12 <olle> null, you know why?

22:13 <discocaml> <._null._> match are compiled statically, it allows for the exhaustive check and an optimising compilation

22:13 <discocaml> <contificate> can't lie, I still invoke dune with verbose flag on occasion to see how much of the ocaml toolchain I don't know - sometimes I feel compelled to make a dune project, even for tiny little snippets, because of "just works" aspect once it's all there, even if I don't care for the hardly documented stanzas that you can only find by asking around here

22:13 <olle> just wrap the constructor in something...?

22:13 <discocaml> <._null._> It would also make the pattern syntax significantly more complex

22:14 <discocaml> <._null._> Dynamic checks are done using `if` or `when`

22:16 <discocaml> <contificate> I don't really understand olle's desire but you can use or-patterns (so long as bindings agree) and apply a guard to those

22:17 <olle> contificate, link?

22:18 <discocaml> <._null._> `let if_b_then_A_else_B b = function A _ -> b | B _ -> not b`

22:19 <discocaml> <._null._> `match _ with (A x | B x) as a when if_b_then_A_else_B b a -> ...`

22:22 <olle> cool, can I copy-paste it to the ocaml forum? irc is volatile for me.

22:23 <discocaml> <._null._> Discord is also "not volatile", but sure, do as you please with this

22:23 <olle> Right, Discord :d

22:25 <olle> +1