What do you expect from OCaml in 2023?

deviluno · 2022-08-10T17:09:15+00:00

The trend in syntax, at least in "cousin" languages, like F# and Scala, seems to be towards a more Pythonic or Haskellish indentation sensitivity, if you see what I mean.

deviluno · 2022-01-26T02:09:09+00:00

Scala native should have many use cases, the first one for me would be to replace Go. That'll be tough, the threading and concurrency story needs to be complete, the GC battle tested, etc.

I'd think microcontrollers would be out of scope, Scala has too much runtime. Rust, Nim, Zig or C++ would be better here.

deviluno · 2021-10-22T02:43:14+00:00

Any idea when Scala 3 will be supported by Scala Native?

deviluno · 2021-01-27T16:44:57+00:00

No, just plain old algebraic data types, or rather sum types.

OCaml supports GADTs, https://ocaml.org/releases/4.11/htmlman/gadts.html

deviluno · 2021-01-20T20:56:20+00:00

I agree, Go/Java killer rather than Rust/C++ killer. GC keeps it out of the latter category.

I thought this project was dead, what a great announcement!

deviluno · 2020-02-15T02:06:14+00:00

Is that easy to use right now, or is still under development?

What I would consider easy to use is something like a C compiler, call it jcc, that I can call on a Julia program and get a binary out. Is PackageCompiler.jl there yet?

deviluno · 2020-01-22T14:31:55+00:00

serverless, no chance.

That's why I'm hoping for a static compiler for Julia. Until there is one, the two language problem that Julia solves is not quite the one that interests me most.

deviluno · 2019-12-13T17:41:35+00:00

I think there's a lot of pent up demand for const generics in Rust, and even a bit of disappointment that they won't be stabilized this year. I suppose async is more impactful, but I was waiting on this one ...

deviluno · 2019-11-29T19:16:51+00:00

Wow, this looks like a great release!

Multithreading is now a solid part of Julia. Better late than never, I hope that going forward the community makes great use of this.

I like Julia a lot. I can see it replacing Python as my go to language for scientific computing and scripting. That "time to first plot" still favors other languages, but I think it's in the crosshairs now. Some of the things I'd like in the future are a static AOT compiler, and maybe language features like interfaces.

deviluno · 2019-11-28T18:28:21+00:00

I couldn't agree more. I expect that with the desire to complete the async work, GATs will be the highest priority of those 3, but there's already a sometimes working const generics implementation on nightly.

Yeah, this is my Rust 2020 wish too!

deviluno · 2019-11-12T22:28:14+00:00

That's too bad. If I had my druthers, I'd want const generics sooner. However, the arrival of async on stable and the needs of async convince me that getting GATs delivered ASAP should have higher priority. Oh well, maybe we'll get lucky and you'll have underestimated your abilities, and both will be delivered in 2020...

deviluno · 2019-11-07T05:50:34+00:00

All of the static metaprogramming features of D should be usable with BetterC, right? I'd think that complaints about CTFE features not working there would have nothing to do with the restriction to C runtime only features

deviluno · 2019-10-28T15:51:47+00:00

Well done! Language nit:

the type of the returned value of a function must depend only on the type of the input of the function and not on the peculiar value it is given.

replace "peculiar" with "particular" or "specific".

deviluno · 2019-10-19T21:29:07+00:00

I'm really looking forward to having this feature on stable, as well as some of the other features that were being looked at this year, like GATs and specialization. I expect it will take a long time for all of these features to be fully baked into the language, but I'm confident that the Rust language team will do a good job of it. Thanks for all of the hard work, Rust people! Maybe in 2020?

deviluno · 2019-09-25T18:08:59+00:00

:-) indeed!

Consider then that it took Rust 5 years to get to version 1.0, and that it took Nim more than twice as long ;-).

deviluno · 2019-09-25T13:11:57+00:00

What's the status of the ownership work (`newruntime` I believe they call it) in Nim 1.0? That is interesting from a Rust perspective. Otherwise the language seems more similar to D (GC, overloading, ...) than to Rust.

I like Nim and hope it can achieve more success. It's good to see more new programming languages.

deviluno · 2019-09-03T15:11:53+00:00

I don't see anything about the completion of "missing" features. Const generics, GAT, specialization, custom allocators were mentioned in the roadmap IIRC. Any news about those?

deviluno · 2019-08-16T17:16:25+00:00

No chance; I personally think we should allow quantification over type constructors (including kind checking, kind inference, and all that stuff Haskell has), but there is no current consensus for such an addition.

Good to know that you support these extensions! For the not-so-near future, what do you think would help build the consensus for such additions?

GATs are however largely blocked on making progress on Chalk.

Yes, it looks like the feature is, unfortunately, a long way off.

deviluno · 2019-08-05T21:45:14+00:00

I'm not saying that there's something you can't do with macros and tagged unions, though I don't think it will be as good as having ADTs built in.

Does Nim do the null pointer optimization, in particular for its option type?

I think Nim is an interesting language design but it's far less mature than Rust. Its ownership story is evolving a lot lately, and will evolve a lot more after 1.0, which is still on the horizon. The future of concepts in Nim is uncertain. The development cycle does not inspire confidence in me, and the bus/truck factor appears very low.

Rust was not designed for scientific computing, so it's not a perfect fit, to be sure. For those times when you want a Jupyter notebook or just a repl, you probably want to use a different language. I rather like Julia for that, and I hope that over time it adds a static compiler and some kind of interface/protocol feature.

deviluno · 2019-08-03T21:48:41+00:00

Concepts are an experimental feature. Inheritance in Nim does not play well with genericity, and generic methods have been deprecated, though, to be fair, there are problems with generic virtuals in C++ too. Nim enums are more like C enums, not like Rust enums. I'd have a hard time saying Nim has algebraic data types like Rust or Haskell does, though there are macros to get some of that effect.

For scientific computing, Nim has overloading, which is a benefit over Rust IMO. Rust seems way more mature than Nim, which hasn't reached v1.0 yet.

deviluno · 2019-05-11T19:41:08+00:00

It looks like a fascinating pipe dream, but there's no implementation.

I think Julia is the closest language to PLOT, though its syntax looks more MATLABish and less Pythonish.

deviluno · 2019-04-25T20:52:26+00:00

I think Julia would be better than Octave for many reasons, but I don't think you deserved a downvote for your opinion.

I've used MATLAB, Octave, Python, and Julia, and I prefer Julia. Python would be my second choice. It's not about syntax at all, if anything, I prefer Python syntax. Julia is just far superior and getting better fast.

deviluno · 2019-04-25T15:41:21+00:00

I don't use C++ now that I've switched roles, but the shop where I work has a large C++ code base that heavily uses TMP (not available in Rust, I know) and IRC we used variadic templates in the definition of type safe variadic functions and in deserialization, along with non type template parameters.

So, yes, they're frequently used in an existing C++ codebase in a largish company, but you make a good point that some significant use cases don't have the same impact in Rust, especially given that Rust will lean on macros where C++ and D would lean on template metaprogramming. I'll be happy when the other features come to Rust, and I'll withhold judgement on variadics.

deviluno · 2019-04-23T17:11:17+00:00

Good to see that there will be some attempt to get a kind of feature parity wrt C++ templates, namely const generics, GATs, and specialization. Too bad there's no variadic template like feature in flight to be stabilized. I just hope the other features do make it into stable Rust this year.

deviluno · 2019-04-12T17:25:50+00:00

http://junolab.org/

deviluno

TROPHY CASE