dataenforce VS MLJ.jl

The dependence on library authors is always a challenge in any language. You might have one author using `[a]` where another uses `PositiveNumeric a, Fin n => NonEmptyList n a` for the same thing. You can always just annotate whatever the library author used (e.g. they return a list of strings, so you use List[str]).

There are some interesting further add ons that seem very python, allowing you to go further. For example, with a pandas dataframe you can just say your type is a dataframe which isn't so useful, but it's possible to hack your own types onto it in the vein of https://github.com/CedricFR/dataenforce, or use things like https://smarie.github.io/python-vtypes/ to get smarter typing on things the authors didn't type. I expect that trend will continue.

What fascinates me about python's types is actually the very fact that they are bolted on. You have a language that lets you do crazy things and a type system trying to catch up and make it convenient to verify those crazy things. It's a nice complement to the usual developments of verifying all of the things and slowly extending the set of things you can do.

https://github.com/CedricFR/dataenforce enforces column names and types, no versioning though. My first instinct is that important data should be stored in databases which enforce schemas, and that should be separate from the python code that reads it.

MLJ.jl is a good Julia ML framework. There's also a Scikitlearn.jl but its more of a wrapper around the sklearn I believe

MLJ is a machine learning framework for Julia, which you can kind of infer from the article but it's not super obvious IMO.

The Beta Machine Learning Toolkit is a package including many algorithms and utilities to implement machine learning workflows in Julia, with a detailed tutorial on its usage from Python or R (no wrapper packages are needed) and an extensive interface to MLJ.

You should definitely go with Julia. It has steeper learning curve than python, but it is way more powerful. As for the ecosystem, you shouldn't worry about that much: DataFrames.jl and friends is way better than pandas, MLJ.jl (https://github.com/alan-turing-institute/MLJ.jl) and FastAI.jl(https://github.com/FluxML/FastAI.jl) are great frameworks for regular ML and deepnet. And if at any point you get a feeling that you need some python library, you can always plug it in with PyCall.jl(https://github.com/JuliaPy/PyCall.jl).

Imho, Julia is more diverse in the sense that there is not a single popular ML library. Maybe the Julian equivalent for scikit-learn is MLJ.jl. There is also ScikitLearn.jl, which defines the usual interface of scikit-learn models, and specific algorithms then implement this interface.

Then you haven't looked at Julia's ecosystem.

It may not be quite as mature, but it's getting there quickly.

It's also far more interoperable because of Julia's multiple dispatch and abstract types.

For example, the https://github.com/alan-turing-institute/MLJ.jl ML framework (sklearn on steroids), works with any table object that implements the Tables.jl interface out of the box, not just with dataframes.

That's just one example.