Відео

How often do names change? Really? A straw man leading away from the many upsides of Merkel trees for “versioning”. In actuality, I would even include the name of definitions into that Merkel tree itself.

Love to see that Roc is getting more pragmatic!

4:42 Not a big issue but I hope some day compiler will be smart enough to understand that non-empty compile-time list is never empty :)

I've literally just saw Jose Valim on ThePrimeagen show telling that he tries and tried to bring imperative while loop in functional language.

This is super clever!

great people are presenting in your group

I've been following Roc for a while now (I did the advent of code in it last year!), and I was just wondering, what was the reasoning for only using a naming convention of ending impure functions with "!" instead of requiring "!" as an operator when calling impure functions? It seems to me that it would be simpler to have it be based on the type of the function being called, similar to how "?" or "try" are often used for calling fallible functions (e.g. Zig, Rust). Was it mainly so that changing a function from pure to impure just causes warnings rather than type errors? Also, I'm a big fan of the approach of keeping a simple distinction between pure and impure functions. For a while, I was working on a compiler that supported annotating arbitrary effects (including effect-polymorphic types and functions) as a personal project, and it led to a lot of complexity that probably isn't worth it in my opinion (especially regarding type inference and compiler errors). I'm excited to see where Roc goes!

Roc is looking spectacular! 🎉 I wish Richard and friends would hurry up and get it out the door. LOL.

At 26:00, if you put another function within the printAsteriks! function that mutated totalPrinted_, wouldn't that one be unpure?

Great talk as always! I really loved the -> and => features, and using the bang (!) to unwrap the result is awesome. I’m not too sure about the var x_ = 1; x_ = x_ + 1 syntax, though. I think something more explicit would work better for mutability. Like var x = 1; x <- x + 1

LOL I was prepared to be surprised, turns out its just effectful types. Also, Julia-like in place mutation convention.

awesome :D

Cool vid! Just to say the feature attributed to Gleam's at around 50mins doesn't exist in Gleam. Gleam doesn't have anything like that as we prefer to always keep it explicit.

Super talk, plus great Q&A dialogue at the end.

Man, so fun audiences :)

Great video!

Sounds like the mic is about 15 feet away from the speaker.

Lots of great ideas here. However I think this makes dependency management really difficult. For example, if you have a large function which is found to have an important bug in some old version, it seems like it would be really hard to identify the users of that code and patch the bug just for the affected cases.

I don't like type-inference. "Explicit is better than implicit". Reading other people's code in languages with type-inference can sometimes be very confusing. I see type annotations as more documentation for the reader/maintainer. If a feature makes it easier to read other people's code and harder to write your own code, then reading trumps writing and it's a good feature. and If the converse is true, it's a bad feature. "Typing [as in pressing keys on the keyboard, not type-systems] is not the bottleneck".

nice work...

Hey, great talk! I am wondering how you get the hx attributes for lucid?

Efsanesin hocam

great insights

no mutable variables == no mass adoption

THANK YOU

For those interested, I recommend Koka. Really incredible language.

If it had array programming where the old arrays were dropped after writes, I would use it

Comedy!

Would we still need Elm if we have Roc with a corresponding Web UI library?

The questions intermission ends at 49:32

I came up with this idea of storing programs in structural format aroun 2013 - originally thought its future just like you think. I later however found value in the text representation - just more structured languages, but still text. I think now that is future not this. Also learned that big-idea languages usually are not the future - they are useful experiments as full-size prototypes more often than solutions. -- But its really interesting to see something similar to what I imagined back in uni (and also talked to people about) come to exists ;-) Its also so interesting to see its "same core idea made differently" - also the distributed part is interesting and all where you went with this idea is actually pretty awsome..

“The compiler can always infer the type.” Whoa. That’s pretty cool.

P r o m o S M 👇

I believe the statement at 26:30 is incorrect about Rust. Calling `let fut = get_movies();` does not immediately fire an HTTP request. One must do `fut.await` afterwards (or just do `get_movies().await`.

Promo-SM

fantastic and easy to grasp. thank you so much!

Talk starts at 12:57

This static typing aspect was nicely addressed in Rich Hickey's "Maybe Not" talk which as well covered some conceptual issues in the Clojure's own spec library. That said, this is not about statically typed systems nor about specs - this is all about picking up concepts more accurately whatever the system one is building. For instance, if you heavily lean onto things like Optional/Maybe/Either because of lacking proper Union types in your language's type system, you are screwed.

I am humbled and elated to see such great language design!!! Looking forward to see isomorphic Roc code, so we may use it for both web server and the browser. What about type classes and generics?

Does NoRedInk intend to use it in any capacity

I have trouble watching a presentation by a guy who is not smart or less self-centered enough to lower the resolution of his screen so that his presentation can be readable on UA-cam. What I do, I just move on! Not worth it.

I utterly love this. Btw, one thing to consider re runtime: WASM & WASI.

I’m i 0:28 0:28

I already know I'll use the catchall errors return "ahhhhhhhhhhhhhhhh"

Love it, but those numbers need to be fixed, ints and reals should be distinct. Go full numeric tower.

This was awesome! Thanks to the Clojure gratitude slack channel and Thomas Moerman for posting.

i remember using livescript all the way back before node even had async await, and you had to callback hell everything. livescript backcalls thing was so good

So as i understand roc somehow stores type information ay least in test env to run program without undefined behaviour?

In PHP i can have types, IDE will complain, but I can still run the program )

Makes you think how necessary is to use zod, io-ts, or other parsing libraries in the js ecosystem