Yes. I really like Julia but I wish there was language that had all of the advantages of Julia but none of the drawbacks (for me it's lack of static typing, function(object) vs the more readable object.function(), 1-based indexing).
I wish there was a language like Julia but with a first-class OOP support. Sometimes the OOP approach is more readable and easier to reason about than functional approach.
Julia is weird.. it's like someone saw all of TypeScript's or F#'s opaque type errors and then thought "wouldn't it be better if all of these could happen... at run time?"
In seriousness I have been enjoying it a lot over Python, but I'd kill for static typing.
It's highly expressive (comprehensions, functional-style all-statements-are-expressions, anonymous named tuples, and heaps more) and these features seem to be usable without sacrificing performance, in a way that I've not yet seen in any other language.
I don't think those sorts of things are a good use case for Julia. Julia is best used for deploying backend mathematics. I'm just suggesting the type system is beautiful, and if someone wanted to implement a more general purpose language with that type system it might be welcome.
Am I the only one with hopes of Julia actually evolving into a general purpose programming language?
With almost C++ level performance and homoiconicity it seems really sweet and I'd love to see it used instead of Go. Though 1-indexed arrays are definitely annoying as fuck...
Julia is really more a functional language than an object oriented one. Not saying that's not a valid point (at least to the extent that favourite paradigm is subjective) but just to point out that it's about more than just syntax.
It wouldn't really make sense for Julia to support object.method() any more than it would for Haskell to, superficial as it may seem.
I've been getting a lot of mileage out of Julia recently, and would counter that plenty of fans of statically typed languages just haven't learned to use an effectively-typed dynamic language.
Thanks for your answer! I think it‘s a tradeoff between syntactic simplicity and explicitness. I enjoy languages like Scala or Rust that are more explicit, but I enjoy Julia as well (partly because of its simplicity).
I really like Julia overall but I'm undecided whether it's good as a general purpose language. Right now I'm working on a few-thousands-lines-of-code project and sometimes wish Julia was more like Swift:
- Writing code with Nullables is cumbersome and verbose compared to Swift.
- The object.method() notation is sometimes more readable, especially in more complex expression. Plus, in an IDE it works well with completion.
- The ordering of types in a file matters.
- Overall, Swift code looks a tiny bit more readable, cleaner.
The issues with the type system and weak static analysis are the biggest gripes for me. The other features of Julia still make using it worthwhile, but it's rather frustrating to code compared to any language with good static type inference and a powerful type annotation system.
the main thing Julia loses from this approach is function types. since each function is a user extendable blob of methods, there basically ceases to be a meaningful notion of the type of a function. imo, this is a worthwhile trade-off, but it can sometimes be annoying (and it's why Julia is hard to compile ahead of time. this pattern makes figuring out which methods you need to compile Turing complete)
Personally I would like to see Julia go full static typing. The dynamicness of its current type system seems to offer me no advantages and is constantly causing me problems with performance. My code ends up covered in type declarations because I'm never sure when types are concrete or not,which kind of defeats the point of implicit typing. A lot of the time a seamingly innocuous change will result in Array{Float64,1} getting changed to Array{Any,1} which then gets propagated automatically though the whole program, since functions can't have return types.
Julia claims to be the future of numerical computing, but they seem to put more effort into coming up with fancy abstractions that no engineer or scientist will ever understand than working on basic numerics. For example, the array implementation is very hit or miss and much much slower than and has much more complicated semantics than arrays in Fortran. I think this is due to the fact that arrays are not first class objects in the language, and probably because the authors don't do much multidimensional high performance work.
It does. I spent several evenings writing little bits of Julia code that do “non numeric” stuff like querying RDF data stores, text processing, etc. I think Julia is a reasonable general purpose language.
The most fun language (having tried lots of them) I put my hands on is Julia, I just love it. You can do so much with such little effort and it can be optimized to almost match the speed of C.
The 2 main downsides is the lack of proper interfaces and object.method() notation, which is sometimes more readable.
Julia is regarded as similar in syntax to python, or at least they have similar readability. What I love about it though (fyi not a CS degree person here) is the elegant way it handles types, and generics. User defined types perform just as fast as the built-ins, and I never seem to labor over design choices needed to generate fast computation.
Multiple dispatch is such a great way not to have to write boilerplate code for every method, somehow java seems very awkward in comparison.
Julia feels like a thoughtfully designed and carefully constructed language. I don’t havd the training to understand why exactly.
reply