seanstrom

Not a lisp apologist haha, but I think Clojure tries to use fewer smooth parens “()” in general. Square parens “[]” and curly parens “{}” are used to help with things like variable declarations and stuff like data structures.

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.

I wonder if building a custom language is a simpler way to optimize stuff later on?

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#.

For a moment I thought this was my fault because I had just asked for a free academic license, and somehow that would be the final straw :(

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.

Awesome resources! On a side note have you tried the Rescript [0] or Reason [1] programming languages? They both are based on OCaml and compile to JavaScript.

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

Yeah these are good points. I guess we could also add AI to the list (AI before ML), since it also has use of calculus I think.

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).

Hey I was wondering what maths are at the foundation of computer science. Could you explain which ones you think are at the foundation?

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?)

As a fan of ML family languages I have a question for SML lovers. What do you typically build with SML?

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?

I keep seeing comments about static html vs generated html. So I have a question (please respond):

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

I’m in the same boat, I’m learning game engines and so many libraries are in C++.

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?

Not sure how to exactly to build a "generator" either, but it seems that it would be a build rule that generates multiple outputs from multiple inputs right? If that's the case there's a `foreach` function for convenience, but it doesn't seem to have something for multiple commands. Though there's this Lua example on their website that leaves me wondering if what you want is possible, here's the code (since the documentation seems offline atm):

```

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/...

Please someone mention Tup and how it can be a reasonable build system. I’ve heard the Fuse dependency is not ideal, though I felt it had a nice UX experience with the Lua config.

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/

I think they meant his psychological analysis of Disney movies that are on YouTube. Not JP’s political lectures or etc.

Honestly, don’t really know much or care much about Svelte for my own use. But hearing that someone is going to be sponsored to work on their invention full-time is wonderful. Glad to witness this personal victory and sending good vibes to help make Svelte great.

I really enjoy this style of humor. Especially when mocking micro benchmark culture and all of the weirdness that happens in those measurements.

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.

Have a look at ProseMirror, let us know if this seems like what you want!

https://prosemirror.net/