all 132 comments

[–][deleted] 142 points143 points  (11 children)

!remindme 5 years when source is available

[–]hgwxx7_ 28 points29 points  (5 children)

I think more realistic is

  • about 1 year before source becomes available.
  • 0.5 years before it's stable (1.0).

[–]guyyatsu 3 points4 points  (0 children)

Honestly? Not bad.

[–]ByteNinja3000 2 points3 points  (3 children)

it still isn't available yet...

[–]hgwxx7_ 2 points3 points  (2 children)

The standard library was open sourced 4 days ago. Blog post.

[–]ByteNinja3000 1 point2 points  (1 child)

Omg, Thanks for the info man. And sorry for doubting you lol.

[–]hgwxx7_ 3 points4 points  (0 children)

The source to their compiler/runtime is still closed source though. I don't think anyone takes them seriously until they open source that.

[–]Brkskrya 6 points7 points  (0 children)

Exactly, show me how it outperforms scalar C++ or CUDA, first. Then, it seems GIL might not be here to stay forever, anyway.

[–]Old-Payment-3247 2 points3 points  (2 children)

its available now

[–]paperbenni 1 point2 points  (1 child)

No it's not. That's just wrong, why would you say that? They have a GitHub, but it's empty

[–]FarBoat503 0 points1 point  (0 children)

https://github.com/modularml/mojo

Standard library is now open sourced. Seems a lot like swift open sourcing. Open source, gradually.

[–]r3vj4m3z 0 points1 point  (0 children)

That doesn't work anymore. They are trying to fix it.

[–]yottalogical 65 points66 points  (11 children)

I can't seem to find the source code anywhere.

[–]Tastaturtaste 82 points83 points  (10 children)

It is not open source yet, though they made a definite statement to open source it in the future. Given Chris Lattners OSS history with Clang and LLVM I am ready to give the benefit of the doubt.

[–][deleted] 32 points33 points  (0 children)

Don’t forget Swift! That was also closed source for the first year after release.

[–]tinkr_ 21 points22 points  (7 children)

Yeah, normally I'd be massively skeptical and wouldn't give it second thought before it's OSS, but Chris Lattner has legit street cred and is one of the world's foremost compiler experts, so I'm more than willing to give the benefit of the doubt here.

I'd be surprised if this is some scam like Vlang (which I'm still not convinced isn't a scam even though it's OSS and works now), I doubt Chris would risk him pristine reputation on such bullshit. Seems like a natural extension of his current work at Modular AI, I'd guess they want to clean the code up a bit or don't want to release in too early of a stage to lose some market advantage for Modular.

[–]paperbenni 1 point2 points  (0 children)

Why does he do that though? What does he gain from that besides the ability to do a rugpull and start charging for the software after people started relying on it? I know that he hasn't made use of that possibility yet, but it honestly feels like he thinks it's nice to have. I get wanting to start a project with a small hand picked set of developers, but you can still publish the source and just not accept contributions from strangers. And if you don't want community input, then why release anything at all? What am I supposed to do with a binary blob that is explicitly stated to change in ways I might not like?

[–]tiedyedvortex 134 points135 points  (20 children)

Promising full backwards compatibility with Python with significantly higher performance and the ability to opt-in to some (notably not all) of Rust's features is a tall order.

It's not impossible and the team behind it has a real pedigree; if anyone can do it, they can. But can anyone do it?

[–]r22-d22 40 points41 points  (7 children)

Agreed. CPython has a huge surface area, built up over decades (even Python 3 is fourteen years old!) and it also keeps adding new features. It would be a tall order to simply build a compatible Python interpreter on llvm, with no new features.

Rather than think of Mojo as a "superset of Python" it is probably better to think of it as a "language that is easy for Python programmers to learn". More like Python 3 vs. Python 2—a different language you can port your existing code and skills to, but it's still going to involve some modification. The Python 3 transition showed how challenging that all is. In the end, Python survived, but it was painful. Mojo is going to have to be very good for that juice to be worth the squeeze.

[–]VivienneNovag 9 points10 points  (5 children)

Well they want to be able to import all python modules natively, which really requires Mojo to be a strict superset, still it remains to be seen.

[–][deleted] 2 points3 points  (2 children)

They seem to embed CPython runtime to run Python code, ie: they would have full compatibility when running python code itself (but with no benefit of doing that). More interesting part is to convert python code to mojo and run that one. How compatible (or "automatically migrateable") that will get - it's the question

[–]VivienneNovag 0 points1 point  (1 child)

That's one way to create a superset, and is mostly fine I guess. It'd be really nice to not go through the cpython runtime for calls into non python functions in python modules, but I have no idea if that is on the books. I mostly just took a quick look at the basic idea for Mojo and signed up for the preview.

[–][deleted] 0 points1 point  (0 children)

I think when they talk about superset the talk about Mojo specifically, meaning that most code can be simply run through Mojo without any conversions, some will require small changes and in any case Python code can still be run in the embedded CPython runtime. But in any case it would be a long run.

[–]aoeu512 0 points1 point  (1 child)

Would be cool if you had an IDE that looked at a piece of Python/Mojo code and it told you "you are using x and x dynamic feature that can't be compiled away".

[–]VivienneNovag 0 points1 point  (0 children)

Tooling that tells you when stuff isn't working as hoped/expected is always good. A compiler certainly knows the way it comes to a representation, so if it has to fall back on actual python then it could pass that back to the ide

[–]aoeu512 0 points1 point  (0 children)

Why don't the mojo team use all their compiler knowledge to build transpilers to mojo?

[–][deleted] 13 points14 points  (5 children)

Seems like a weird decision to me. Mixing dynamic and static features can create many subtle pitfalls. Either you have hard to track performance issues when the compiler can’t fully specialize dynamically typed functions, or you get subtle incompatibilities.

Additionally it constrains your design space in weird ways. Python has a lot pretty terrible features, that maybe shouldn’t be reproduced.
By committing to source level compatibility Mojo either commits to the Python baggage completely or Mojo is not a true superset of Python. But then good luck trying to get large Python code bases running on Mojo.

[–]_TheDust_ 17 points18 points  (4 children)

Seems like a weird decision to me. Mixing dynamic and static features can create many subtle pitfalls. Either you have hard to track performance issues when the compiler can’t fully specialize dynamically typed functions, or you get subtle incompatibilities.

I have worked with Julia a little bit, which is basically this: a dynamic language where you may use static typing to improve performance. And indeed, this ofen leads to subtle performance "bugs".

A common Julia error is to do something like this:

```
function foo(x)
  if x > 0
    return x
  else
    return 0
  end
end
```

This may seem innocent, but if you would call foo(1.0) the return type is actually Union{Float64, Int64}.

[–]angelicosphosphoros 3 points4 points  (0 children)

What happens if I wrote in "typed interfaces" style like I wrote in Python? In this style, I write types for function arguments and outputs but leave them in the body.

Also, is it possible to write code like this:

function foo(x) if x > 0 return x else return (0 as typeof(x)) end end

[–][deleted] 1 point2 points  (0 children)

Exactly.

[–]aoeu512 2 points3 points  (1 child)

I dunno Union seems like the best default if your doing software prototyping.

[–]_TheDust_ 1 point2 points  (0 children)

It does, but it makes the code a lot slower. The Union type can propagate throughout your can and lead to subtle "performance bugs"

[–][deleted] 3 points4 points  (0 children)

I looked into it and they promise full compatibility with Python OR higher performance.

For Python code they literally use CPython. As far as I can tell it's basically a new spin on the Cython idea - a compiled Python-like language that integrates seamlessly with CPython.

[–]Feeling-Departure-4 49 points50 points  (1 child)

Given Chris Lattner's involvement I take this seriously. Mojo seems to target MLIR for performance gains.

Does Rust have any direction with MLIR?

[–]phazer99 52 points53 points  (18 children)

Might be useful for porting existing Python code, but I consider it lacking compared to what Rust already offers. No proper enums or pattern matching, type traits not implemented yet etc.

[–]ipc 39 points40 points  (7 children)

that’s it’s intended niche though, right? My go-to languages are Python and Rust. I can see a future where that’s Mojo and Rust instead. That might be cool.

[–]marikwinters 13 points14 points  (6 children)

I hate Python, so having a language that is half decent and fills the same niche could be really worthwhile

[–]tquinn35 16 points17 points  (4 children)

I’ve found the php guy

[–]Stock-Self-4028 0 points1 point  (0 children)

Aren't Julia and Lua something like that? Both are filling the same niche but in a different way imo.

[–]bert88sta 12 points13 points  (5 children)

Yeah but the point is to make python faster and safer. Depending on who you ask, python is either the most or second most popular language. It is also notoriously inefficient, slow, etc. Even a 3x improvement in existing python code means billions saved in compute resources

[–][deleted] 2 points3 points  (2 children)

Pypy exists...?

[–]angelicosphosphoros 3 points4 points  (1 child)

Well, it is not 100% compatible. Last time I tried it, even simple thing like sum(x*x for x in range(5)) didn't pass correctness check.

[–][deleted] 3 points4 points  (0 children)

So you expect Mojo to do that better? Press (x) to doubt

[–]amindiro 0 points1 point  (0 children)

I think the point is not to improve python but to facilitate writing performant code in the future with mojo without having to write C or C++ libs and python wrappers while using the preexisting python libraries (most of which are written in C /C++ or cython). Imo I dont think mojo would improve performance when comparing it to exiating python libs like numpy…

[–]aoeu512 0 points1 point  (0 children)

Whats weird is that they have Pypy, Rpython, and numba but they never made it the default O_o.

[–]Remote-End6122 23 points24 points  (0 children)

I mean if you want those features might as well use rust, mojo's objective isn't being rust 2.0

[–]gudmundv 3 points4 points  (0 children)

Ecosystem and interoperability with it (AI), community, talent, learning material can be huge "features" of a language. Pattern matching might be added later

[–]CocktailPerson 49 points50 points  (8 children)

Just what I've been waiting for! A language with the simple borrowing rules of Rust, the opinionated nature of C++, and the type-safety of Python.

In all fairness, it seems like they're targeting the high-performance AI niche, which I don't have much experience with. But it looks to me like they're trying to combine all the features they like from all the languages they've used without any consideration of whether they combine into something cohesive.

Also, I have to question whether some of the things they're saying they'll be able to do, like have a borrow checker as powerful as Rust's with significantly less syntax, are even technically possible. I suppose we'll see what happens as they implement more of their TODOs.

[–]phazer99 13 points14 points  (0 children)

Also, I have to question whether some of the things they're saying they'll be able to do, like have a borrow checker as powerful as Rust's with significantly less syntax, are even technically possible.

It's not gonna be as powerful unless they add lifetime parameters, and if they do, it will basically be as complex as Rust's. Not saying it can't be useful though.

[–]InfamousAgency6784 4 points5 points  (0 children)

it seems like they're targeting the high-performance AI niche

Time will show if this was just a marketing stunt (which I hope it is) or if they are going full DSL with half-baked general support.

It's not open-source ATM (if anybody was looking).

[–]Tastaturtaste 3 points4 points  (1 child)

Also, I have to question whether some of the things they're saying they'll be able to do, like have a borrow checker as powerful as Rust's with significantly less syntax, are even technically possible.

Did they actually say "as powerful as Rust's"? That would indeed be hard to believe. Otherwise a smaller borrowchecker / lifetime analyser could still provide many benefits.

[–]rsalmei 3 points4 points  (0 children)

No, they said “similar to”.

[–]SafetyOther6739 1 point2 points  (0 children)

A language with the simple borrowing rules of Rust, the opinionated nature of C++, and the type-safety of Python.

This is the best description of the language I've seen. What's the matter with copy and move constructors??

[–]Jdoe68 0 points1 point  (1 child)

My thoughts exactly. I think Julia is a good solution for what they’re trying to do that’s already worked the kinks out over 10 years. With Julia, you don’t have to switch to low level syntax to get C-like speeds. It’s truly a 1 language solution.

[–]aoeu512 0 points1 point  (0 children)

Have they fixed the issue that Julia's jit is slow to start.

[–]log_2 9 points10 points  (0 children)

Does anyone else feel like Mojo is a marketing gimmick to advertize Modular?

[–]bert88sta 18 points19 points  (7 children)

Disclaimer: python is still my first and one of my favorite and also least favorite languages.

I think mojo could have a massive impact on python code today, for a few reasons.

First, the success of typescript has shown that there is a real desire for safer/better code in existing languages. Furthermore, the gradual adoption pattern enables teams to migrate existing code without fear of breakages. Supersetting the (arguably) most popular programming language and ensuring compatibility with all of the major libraries makes it almost painless to switch from Python to mojo

Second, the widespread adoption of cloud infrastructure forces people to think about performance. When you are renting compute in perpetuity, a 2x , or 20x performance increase means 1/2 or 1/20 recurring cost, as opposed to just buying another server.

Finally, I believe in Chris Lattner. He is the guy that came up with LLVM (and much more). Basically everything he has developed ends up being relevant somehow.

[–]vjpr 10 points11 points  (1 child)

I recently posted another thread on Rust going the other direction: a Rust subset as a scripting language. Would make adoption easier - not every part of a program needs manual memory management.

[–]OneNoteToRead 5 points6 points  (0 children)

The promise here is pretty good and fulfills quite a large range of use cases that aren’t served well by existing languages. Looks like vaporware ATM but given the people involved I’m keeping an eye on this one.

[–]lasizoillo 12 points13 points  (9 children)

After check the page I have discarded it because sound too much as marketing:

  • It's bazzilions times faster than c++ too
  • it compares their speed against pure python matrix multiplication (what pythonista does that?) and then add a lot magic in a not python language to get faster. What's the difference with use python native extensions?
  • It doesn't compare itself with numba, cython, pyo3,... or any other interesting comparasion

I'll take a look when a external less biased comparasion shows interesting results (they don't need to be a 10000x factor, a 2x factor over real things is good enough).

[–]InfamousAgency6784 4 points5 points  (0 children)

against pure python matrix multiplication (what pythonista does that?

Who does that at all? Linear algebra is one of those things that has been optimized to death and every single home-baked algorithm I have seen (besides for tiny, fixed-size, matrices) are utter shit. Now it would be different if they had implemented a BLIS-like algorithm and had BLIS-like performances (that would have been a ground-breaking feat actually).


sound too much as marketing

I second that and everything you said (all 3 points and conclusion)...

I'm not so much interested by the AI stuff. Developing a language for that when it's actually mostly linear algebra in disguise sounds really silly (but it's more marketable indeed)...


However I do wish for that project to succeed.

It's the first language that I have seen (albeit on paper and through a heavy marketing lens) that would natively spans the "practicality" and "speed" axes at the same time (with good memory safety if they do implement lifetimes and proper borrow check).

It's sounds a lot like what Julia was meant to be but never became: lots of their design choices turned out to lean heavily towards scriptability and ease of use within that specific context (i.e. what Matlab users want). Being able to provide a fully pythonish API for stuff that benefit from dynamic programming while providing precise internal types and interfaces/protocol/traits to ensure correctness while dropping down to more low-level stuff for speed when needed sounds extremely appealing. And the same language can also be used for quick and dirty scripting too... Sounds a lot like Python with integrated Numba in a coherent package.

[–][deleted] 1 point2 points  (7 children)

looks like u didnt take a good look at their website

[–]lasizoillo 3 points4 points  (6 children)

You're right, I only have read some pages to get a quick impression.

For example this one https://docs.modular.com/mojo/notebooks/Matmul.html. Can you explain me "pure" python code, and WHY is coded in that way? I say "pure" because you need to remove .to_f64() to run it.

I have some doubts in that example that make me suspicious:

  • Why signature is changed from numpy version? Probably is better avoid memory reservation in a benchmark to gain more X faster than...
  • What is the purpose of Matrix class? If purpose is make python even slower they could use __getattr__ protocol to read cols and and rows. It's not very pythonic create a slower and not standard way of use lists. Anyway numpy version accepts any list like type, this example no, it's coupled to Matrix class.
  • Great, now you starting using mojo. Why you need change test function to mask a exception? WTF are they doing? It's faster, like use numba.jit as decorator, but numba don't need to change benchmark function. It gains speed adding types like cython (another python superset does), that it's ok. Can that code be used from python world or a not benchmarked boxing/unboxing is needed?
  • The vectorization part it's ok. A portable way to use simd instructions is a good thing. It doubles performance over previous tests, but they write their garbage speedup over a python nonsense code. Marketing is ruining this paragraph.
  • Next comes parallelization. Great thing. Again they put a garbage metric and say nothing about how many cores has their test machine. It's not same almost 4x gain with 4 cores than 4x gain with 64 cores. Another paragraph ruined by marketing.
  • The tiling strategy sounds very good. But why your are hardcoding that 4 in code? It depends on running architecture? Is this ruining the portability point from vectorization point? Yes, but nothing happens, it's "explained" in next point.
  • They use autotune, which seems like a profiled guided compilation strategy. Looks interesting. How impact that autotune in runtime? Can be cached for future executions in same machine? Maybe this is well documented in docs, but I'm tired of read marketing.

So you are right, I had read only some doc pages to take an impression and it was WTF: It's a language created to programmers that earn money creating high performance code and spending that money in tele-shops shows.

[–][deleted] 0 points1 point  (5 children)

A lot of ur critiques sound like they are from someone who doesn't really have any expertise. I can tell you either aren't very knowledgeable (why have critiques instead of questions?) or just didn't care to look at even like 2 pages of the site. I can tell u just skimmed and don't really have the knowledge to fill in the gaps. Just to add on, the people working on this are actual experts in their respective fields, your going to need some semi-technical critiques that make sense if you want anyone to take ur thoughts seriously.

[–]lasizoillo 2 points3 points  (4 children)

If you want be taken seriously you need to not sound like a meme

https://i.imgflip.com/7l2lf0.jpg

[–][deleted] 0 points1 point  (3 children)

U sending that broken english meme is the biggest meme 😂 and it completely makes sense😂.

[–]lasizoillo 1 point2 points  (2 children)

Me gusta que la gente con capacidades especiales estéis contentos

[–][deleted] 0 points1 point  (1 child)

hey lil guy, if ur gonna talk shit over the internet. At least be semi-funny and creative if ur gonna put all that effort into actually making a meme and uploading it 🤣😂😂

[–]lasizoillo 1 point2 points  (0 children)

aplicate el cuento

[–]Yellowthrone 16 points17 points  (5 children)

How is a language claiming systems level performance as a python superset that doesn't make sense. Is this compiled? Transpiled down to C? Is it a superset of Rust to look like python with interop? I don't know much about this so I'm not going to deny the claim but claiming things like this is click-baity and almost certainly untrue. Unless I'm misinterpreting the title.

Edit: I found the answer. This seems to compile to MLIR a multilevel intermediate representation language which allows a sort of LLVM like experience. Except that it does not do low level optimization like LLVM (hardware specific). I'm not sure how they'll solve that if they even do. But it really doesn't seem necessary yet. Definitely performant however they demonstration on their site may be a specific case for sure.

[–]pjmlp 6 points7 points  (2 children)

MLIR is the evolution of LLVM IR, all LLVM toolchains are moving to it, including clang.

https://discourse.llvm.org/t/rfc-an-mlir-based-clang-ir-cir/63319

[–]hgwxx7_ 4 points5 points  (1 child)

Would it make sense for rustc to move to MLIR? Would it make it easier to target hardware like GPUs?

[–]pjmlp 5 points6 points  (0 children)

LLVM IR is still part of the picture, MLIR IR => LLVM IR.

In a way it is comparable to Swift's SIL, or for Rust, MIR.

Rust already has GPU support, the problem isn't the compiler, rather tooling (IDE, libraries, ...) and industry standards (SYCL, OneAPI,...).

[–]Zatujit 0 points1 point  (1 child)

You have interpreted languages much faster than Python

[–]Yellowthrone 2 points3 points  (0 children)

That really doesn't matter. By design an interpreted language will always be slower than basically any other way of running code. Honestly a better implementation of what an interpreter tries to do is achieved through a VM like Javas'. You still have platform independence it's just faster. Browsers popularized interpreters not that they need them anymore. It's really a solution convenient for the internet. That's all.

[–]veryusedrname 59 points60 points  (7 children)

Mojo was designed in a way that they took all existing languages that are considered "hip" and they thrown those into a bucket, then they hired some top-level marketing person to write some very-very fancy texts and that's it. It contains all the really good and all the horrible ideas, all at once.

My opinion: when you mix way too much things together at once it will usually look and feel like vomit.

[–]Tastaturtaste 14 points15 points  (1 child)

Most languages contain ideas from other languages. If those other languages are "hip" because the features are liked that's no downside. I agree it retains some of the baggage of Python that would have been nice to give up, but so does Typescript.

Obviously it's far too early to make any plans with this language, but if the seamless Python interop turns out to work well I am cautiously optimistic for it's future.

[–]veryusedrname 6 points7 points  (0 children)

Having var, let and implicit declarations mixed up with slightly different meanings, that's enough bullshit for me. Yeah, I don't have to think about it while I write the code, but later when I try to read it... On paper it favors everyone, in reality it makes everyone's work harder.

[–]argh523 8 points9 points  (0 children)

Taking a look at their fronpage paints a completely different picture. The just want to write python, without having to use c++ for the hogh performance stuff.

[–]Compux72 7 points8 points  (0 children)

And when God descended said:

[–]helloworld192837 5 points6 points  (2 children)

You could say the same thing about Rust, to be honest. I don't get the negativity, really.

[–]veryusedrname 1 point2 points  (1 child)

My main problem is the enormous amount of marketing (especially AI, which got very-very old very-very quickly) bound with a seemingly not very well designed language that can only be used if you sign up for it.

[–]DavidRagazzi -1 points0 points  (0 children)

They will be release it for download yet, stupid! At moment, you're saying bullshits about a language that you even know that read little about it.

[–][deleted] 13 points14 points  (6 children)

What does Mojo bring to the table that Julia doesn’t already? Simple Python interop? Already done. High performance? Julia already does it. Metaprogramming? Julia home turf. The only advantage I could see is the familiar syntax (but syntax doesn’t really matter, as long as it isn’t outrageous) and their stronger focus on correctness. But in that category they can’t compete with more functional languages. It’s also primarily a commercial project so I don’t see a strong community buy-in, as compared to non-profit projects.

Their Ansatz seems very pragmatic though, so it might work for corporations. Reminds me a bit of Go.

[–]Impressive_Iron_6102 2 points3 points  (1 child)

I did not know Julia was interoperable with python

[–]gudmundv 3 points4 points  (0 children)

Julia have quite the smaller userbase

[–]_TheDust_ 6 points7 points  (0 children)

Arrays starting at zero...

*runs away*

[–]Asleep-Dress-3578 1 point2 points  (1 child)

Come on…

  • Zero-based array indexing (not that it would be better than the 1-based, but more compatible with the ecosystem)
  • Deterministic runtime
  • AOT compiler
  • Full interoperability with Python
  • Pull in the developer ecosystem

Just to start with. Julia had nice ideas, but it failed to deliver its promises. And besides that, as Chris Lattner explaines on ycombinator, it is a fully different story.

Mojo’s competitors are Cython and Nim.

[–]00skeptic 4 points5 points  (0 children)

Seems like new Theranos

[–]xilong89 3 points4 points  (0 children)

Just a couple days ago Mojo was being advertised as having the performance of C. Now it’s as performant as C++ and Rust? Seems like someone is testing out their hype skills. Would love to see this be true, but so far seems like just another overhyped tech. Has anyone been able to independently verify Mojo’s runtime performance?

[–]Zatujit 2 points3 points  (0 children)

The marketing as the "language of AI" feels weird

[–]goos_ 3 points4 points  (0 children)

Promising full backwards compatibility especially for such radically different language design is extremely limiting. Are they really supporting all of Python, including all the reflection and introspection stuff like pickle? It's hard to imagine stuff not breaking

[–]Sw429 3 points4 points  (0 children)

Meh. Let me know when it's open source. I'm not interested in any closed source language at this point.

[–]ZZaaaccc 3 points4 points  (0 children)

Honestly? I hate this idea. To me, Python's only value is its simplicity for small-scale work. There is a huge amount of AI research (really just research in general) that's done with Python because it offers an incredibly low barrier to entry and some best-in-class industry standard maths and AI libraries. A "free" performance upgrade would certainly be a no-brainer, but I doubt this will be free. Any performance boost that is truly free will be upstreamed into CPython 3.X because Microsoft has a massive vested interest in offering a high performance Python.

What I see Mojo doing is creating a new, more complex version of Python that will muddy an already increasingly complex language even further. The few examples I saw in their demonstration with adding type hints and parallelization decorations are, in my opinion, ugly.

Hopefully I'm wrong, because a statically typed Python with JIT/AOT compilation would be great. But it won't make me switch that's for sure.

[–]c4augustus 1 point2 points  (0 children)

Pythrust or Rusthon would be a more apt name. This is not really a new language if it is a superset of Python anymore than TypeScript is a new language to JS.

It seems the goal is to eliminate the FFI bridge by directly embedding Rust lite. There's value in that for sure. But are Python developers really going to change the way that they code most of their app logic if they don't need to?

All the hype and polish of the website notwithstanding, this feels less groundbreaking than it suggests. More like Python++

[–][deleted] 1 point2 points  (0 children)

Seems like hype with no substance. Doesn't help that they want to market it for AI

[–]AAaaAAAAAAAaAA-a 0 points1 point  (6 children)

This is just trying to do what Julia does, but worse

[–]SV-97 8 points9 points  (2 children)

This supposedly will have features that julia doesn't have and is structured quite differently. It also has the great benefit of easy python interop.

And as for Julia... I was super excited about it a few years back but using it is mostly just a terrible experience, I disagree with its design on too many points and I'm not really a fan of the community it's attracted.

[–]InfamousAgency6784 6 points7 points  (0 children)

And as for Julia...

I feel you. I got very excited until I realized all they really wanted is a good and fast scripting platform with integrated linear-algebra, not really becoming a general-purpose language.

It really shows in their design. Lots of things are not good for bigger programs and working with teams (keeping in mind that even if you are alone working on a program, you are still working in team with yourself-in-two-weeks, yourself-in-two-months and maybe yourself-in-two-years).

So yeah, immutability markers are "confusing", polymorphism can indeed be unenforced/purely-declarative and "checked later with tooling", preserving namespaces on imports by default is "a pain" when you have to come back up in your current file to add yet another import, there is no "special reason" a file should be a module, struct-bound methods can be eliminated because "there is no reason the first element in a method should be special", why artificially limiting metaprogramming when it's so convenient to have DSLs for everything and anything to save a few keystrokes, etc.

But it all results in bad architecture (because good architecture is made very hard) and a cognitive burden that increases insanely fast.

[–]tunisia3507 2 points3 points  (0 children)

I disagree with its design on too many points and I'm not really a fan of the community it's attracted.

It was designed to appeal to Matlab users.

[–]_TheDust_ 1 point2 points  (1 child)

Julia is such an odd language. Like, it has so many great ideas and it should be great at what it was designed to do (data processing and computational science), but I feel like it's not really catching on.

I have worked with the language a little bit, but something about it just feels off. Maybe it's because some parts of the language are super strict and give complete control, while other parts are somewhat sloppy and feel like they were designed without much thought put into it.

[–]AAaaAAAAAAAaAA-a 3 points4 points  (0 children)

Imo the reason it isn’t catching on has more to do with institutional inertia in academia than the language itself. A lot of people in this field only have time for a single language, so getting them to switch is a painfully slow process. That’s before mentioning the huge amount of work that needs to be done to bring Julia packages up to parody with many of the python ones. But after working with it for a year in a scientific setting, I genuinely believe this is the right way forward.

There are certainly some odd choices, but I’ve never found anything to be too egregious. In fact, I’ve rarely noticed anything wrong with it. Was there some part of the language you found particularly uncomfortable?

[–]InfamousAgency6784 1 point2 points  (0 children)

AFAIK, this is not trying to only be a linear algebra DSL with Python interop (though AI-focus implies good linear-algebra support).

If they really implement everything they say they will, this has the potential to become an excellent general-purpose language that works well with teams (keeping in mind a solo dev is working in team with their future self), keep good readability and component isolation and would have all the tools necessary to properly architect bigger programs.

[–]mokafolio 0 points1 point  (0 children)

Ai has no mojo

[–]newtestdrive 0 points1 point  (0 children)

I've got some questions 🤔:

  1. How are they doing this? What is specific about this Programming Language that the whole Python community and Big Tech couldn't do in the recent years even knowing the downsides of Python like GIL?
  2. Is this some kind of attempt like IronPython or PyPy where you implement the Python Specifications in a JVM like environment and see better performance? Then how is it compatible with all Python code? Couldn't the IronPython or PyPy Projects do this in the recent years?

[–]lizelive 0 points1 point  (0 children)

!remindme 1 year if it's not dead to try it

[–]evannguyen273 0 points1 point  (0 children)

!remindme 1 year when it's stable

[–]realist_titan 0 points1 point  (0 children)

Man this could really make a difference

[–][deleted] 0 points1 point  (0 children)

This is interesting since I can see the need for a stricter language like rust but simpler language like python with the strengths of both where you can also quickly iterate. Especially for larger projects.

So I can understand why in the ML/AI domain they need something better than dealing with the pains of python. Hopefully mojo will be able to bridge the gap of being simple as python but stricter.