I recently started using Clojure and I’ve used languages like C#, JavaScript, and Python a lot. My two cents is that a Clojure-like language should try to embrace the aesthetics of a white-space language like Python, but use the parens as clues for scopes or blocks. So much could be done with formatting rules that just make parens easier to scan without some extra IDE highlighting or something.

The best part of parens is that you can try to pick a consistent format, but ya know that sometimes doesn’t happen because everybody likes to use parens differently lol.

For example, Unity uses C# but then you need either all of Mono at runtime or something like IL2CPP to compile to C++. And then eventually that compiler is constantly needing to keep up with language releases and new features. Or in .Net’s case new languages like F#.

I was very excited to start reading the C code and was hoping a Nim port would be possible. Sad to hear I’m this late to the party because now I can’t even enjoy the blog posts.

[0] https://rescript-lang.org/ [1] https://reasonml.github.io/

I’m now wondering whether to consider both of these subjects foundational to CS or a CS degree. My gut says yes since so much relies on ML and AI is used a bunch (e.g. games and stuff).

For context, I’m not sure something like calculus would be a foundational math (though it could be), but something like Boolean logic would be (right?)

For context, I’m web programmer and I’m also learning game dev, can I use SML productively?

Or are there other tasks that I could use SML for?

Why can’t we just run the example Deno program to generate snapshots of html?

It seems like some of us think pure static html is a good goal for some things, so why not use this Deno program to create the same html responses in generated files?

It’s probably the same amount of code because instead of writing a http response you write a file.

Of course you lose some functionality this way, but your app you rules imo

It feels impossible to use Rust or Zig, but I have hope I can use Nim. It can compile to C++ and has a simple-ish way of wrapping C++ code. Maybe it would interesting for you too?

```

inputs = { 'file1.c', 'file2.c' }

outputs = { '%B.o' }

commandA = 'gcc %f -c -o %o'

commandB = 'gcc %f -o %o'

objects = tup.foreach_rule(inputs, commandA, outputs) tup.rule(objects, commandB, {'app'})

```

Which apparently is a shortcut for saying:

```

tup.definerule{

    inputs = {'file1.c'},  
    command = 'gcc file1.c -c -o file1.o',  
    outputs = {'file1.o'}  

tup.definerule{

    inputs = {'file2.c'},  
    command = 'gcc file2.c -c -o file2.o',  
    outputs = {'file2.o'}  

tup.definerule{

    inputs = {'file1.o', 'file2.o'},  
    command = 'gcc file1.o file2.o -c -o app',  
    outputs = {'app'}  

```

Reference: http://web.archive.org/web/20201026140926/http://gittup.org/...

Plus it’s worth considering that you can potentially use Fennel to configure the builds (since Fennel compiles to Lua).

Tup: https://github.com/gittup/tup

Fennel: https://fennel-lang.org/

And fwiw it definitely seems good to call out “bad play” in the community, but a lot of open source is based around clout and “micro-fame”. Not sure what helps that problem.

https://prosemirror.net/