timdeve

It appear to download windows on the fly from Microsoft's server and uses trial keys [0]

[0] https://github.com/dockur/windows?tab=readme-ov-file#is-this...

This appear to use https://github.com/dockur/windows which is a VM inside a Docker container?

Otherwise looking at the code this feels like something that could be a short bash script wrapped in a electron app.

This is really lovely.

Would be great as an inspiration tool if it would make a little visualisation of the notes/accent/slides on a piano roll.

I can read the JSON meanwhile but just an idea.

The gendarmerie have their version of Ubuntu so they may go for something similar. Not that different part of the French government communicate or help each other...

Looks good, I'm gonna try to swap readability in my RSS reader with this.

And with Pocket going away I might have to add save it later to it...

Made my own, made it easy to add different type of clients (TUI, Android, Web) and display cleaned up articles.

Yeah I would really like Pine64 to take a stab at this form factor. I guess the closest is the keyboard for the pinephone but that's a tiny screen.

The goal is certainly to have a language suitable for "real-time applications" (read games/audio), that's not my area of expertise however so your definition of real-time might not be different than mine.

As it compiles to C, any microcontroller with a compiler that supports something that looks like C can work. I've run Carp code on a GBA (as mentionned somewhere else in the comments), esp32, esp8266, as well as Arduboy & Pygamer via Arduino.

There is some more information about running Carp on embedded platforms in the docs[0].

One last thing I wanted to mention is that Carp is still very much in flux so it might not be the best choice for longterm projects, but if you're interested in playing with the language there is usually always someone to answer questions on the Gitter[1].

[0] https://github.com/carp-lang/Carp/blob/master/docs/Embedded....

[1] https://app.gitter.im/#/room/#eriksvedang_Carp:gitter.im

Don't get too hung up on the "lisp" in that title. I think the language would better be described as statically typed, with s-expr syntax, inspired by Clojure|Rust|ML and with a lispy language accessible for use in macros. But that's less catchy.

Source: I contribute to the language.

That's correct, concurency is not supported right now. I have a POC for using pthread but essentially the borrow checker is not aware of it and so it's quite unsafe.

Note: I'm a contributor.

I'm not sure what you mean by optional parenthesis. I'd say optional separators are a legacy feature, I don't think anyone writes Carp with separators.

Note: I'm a contributor.

As other people have said Bootleg + Hickory.

Here is an, admitedly not very clean, example that grabs stream urls from hltv.org:

https://github.com/TimDeve/.dotfiles/blob/master/scripts/gen...

Also a basic RSS reader using the clojure XML lib:

https://github.com/TimDeve/.dotfiles/blob/master/scripts/gen...

I've been using it for quick web scrapping scripts and it's really nice.

I have a small babashka script to pull some news from my terminal and I have had good result doing something like this:

  curl article-url | readable | w3m -T text/html

I wish that the Clockwork Devterm was this form factor.

The quality of the switches in logitech product in the past few years has become laughable. I am currently using a 8 years old 502 because the newer one I got broke after nine months...

`let` is for declaring variables while `the` is a noop at runtime and only give type information to the compiler.

Carp is statically-typed with type inference so writing (the Int x) would be enough for the compiler to forbid any usage of x as another type. Writing (Int.+ x 1) would accomplish the same as Int.+ only accepts Int.

You can also annotate function with a type signature.

  (sig add (Fn [Int Int] Int))
  (defn add [x y] (+ x y)) 

  (defn add [x y] (the Int (+ (the Int x) (the Int y))))

That is also the case in Carp, x being an expression here.

You're correct, somewhat like clojure's Vector, the default collection at runtime in Carp is an Array which is heap allocated C array with an attached length. At compile time however the dynamic language uses more standard lispy lists.

Yes, exactly, it's because of Structural Typing that you have to implement Phantom Types in that hacky way rather than Structural Typing being the "trick".

Thanks, the screenshots were quite out of date actually so I updated them.

Miniflux sounds like a better, more complete version of my side-project[1], I had rolled my own at the time because I wanted offline caching but it's obviously not that useful anymore in our current work-from-home world...

[1] https://github.com/TimDeve/rasasa

I've been having tons of fun lately making GBA games, it's far enough from my webdev day job to be intellectually stimulating. I'm quite impressed with people saying they use to built games when 12, some of the stuff in tonc took a bit to click for me.

I definitely recommend Aseprite for pixel art, it's really good.

As someone who works on Carp, it seems we're going for one level of abstraction higher than what this is aiming for. It's pretty easy to do C interop but the goal isn't to write "C in S-expressions".

Doesn't mean it doesn't perform well, currently writing a GBA game: https://github.com/TimDeve/radicorn

You should check out Carp[1]. The language is still young but it might scratch that itch.

[1] https://github.com/carp-lang/Carp

Love Carp, the fact that it compiles to C means it can run everywhere like embedded (GBA[1], ATSAMD51[2], esp8266[3]) but is also expressive enough that you could build web apps with it[4].

It's very pre-v1 though so expect breakage and API change.

[1] https://github.com/TimDeve/dino/blob/master/main.carp

[2] https://github.com/TimDeve/carpgamer/blob/master/main.carp

[3] https://github.com/TimDeve/carp-lang-arduino/blob/master/mai...

[4] https://github.com/TimDeve/koi/blob/master/examples/notes-js...

Switched to Feedly and used it for years after Google Reader died, I think it's pretty good.

I wanted offline reading though so I ended up rolling my own [1], it's a bit rough and I don't really need the offline thing since I'm at home most of the time but I still use it out of habit.

[1] https://github.com/TimDeve/rasasa

Prezto default prompt (soren) is async.

If you are interested in game development and lisp, may I suggest having a look at https://github.com/carp-lang/Carp ? It's "A statically typed lisp, without a GC, for real-time applications.", the Gitter is quite friendly as well.