mindB

I think you have a typo mixing up AGPL and GPL. I agree that it would be hard to imagine a company being okay with the AGPL but not the GPL. On the off-chance that it isn't a typo, could you explain why a company might be okay with AGPL but not GPL?

Hi wryl. I'm interested in hearing your follow-up to this post, so I tried to add your log to my feed reader, but I couldn't find an rss/atom feed, which is the only way I'll remember to check back in. Do you have a feed I can follow?

Still not open-source it looks like [2]. I'm not willing to create an account right now. Can someone who has an account post what the pricing looks like if any? I'd also be curious what other agreements you have to make other than the terms of service[1] you agree to when making an account.

[1] https://modular.com/terms [2] https://github.com/modularml/mojo/blob/5823e1d9d176916c236c5...

>Literally nothing has changed

This is super disingenuous in a world where things like the GPL exist and any other license that prevents you from putting further restrictions on the combined product.

I don't think this was the case in 2016 though.

If you'd like to try these tools at home, someone has copied the source onto github[1]. I've only been playing with this for a few minutes, but the only "problem" I've run into so far is that 2html omits the <!DOCTYPE> declaration, but that isn't really a problem for me since I was piping the output through tidy anyway.

I've been looking for a nice way of batch-editing html using some sort of sed-like tool, and this is the best option I've seen yet. Beyond that I just find it a neat idea.

[1] https://github.com/clone/xml2

I'm a very happy Julia user, but what's the point of this blog post? It seems to just be regurgitating a bunch of points from the official 1.9 announcement[1]. There was also significant discussion of the 1.9 announcement on hacker news only a couple of days ago, so posting it here for discussion seems silly.

[1] https://julialang.org/blog/2023/04/julia-1.9-highlights/

The title undersells the magnitude of the change a bit in my opinion. By default, mastodon now encourages new users to sign-up on https://mastodon.social which has caused a bit of a kerfuffle in the fediverse.

Personally, I'm largely ambivalent to the change; I understand the reasoning, and it's what https://element.io has been doing for https://matrix.org since the beginning. It is more than a bit of a sea-change though given the fediverse's prevailing culture.

I tend to agree that Julia and other modern programming languages with hygenic macros aren't "homoiconic". Maybe GP is making a point about the title of this presentation? Read generously, maybe he's criticizing calling this homoiconicity by comparing it to Julia which originally claimed to be homoiconic but removed the claim from its website because of contentiousness[1]?

[1] https://groups.google.com/g/julia-users/c/iKxqn-J9frI/m/QzaS...

To be fair to yourself, LispSyntax.jl is more of a proof of concept than something that anyone would want to actually do significant coding in as can be seen by the TODO list in the README[1]. It also hasn't seen any active development in several years.

[1] https://github.com/swadey/LispSyntax.jl

I don't remember C-c being broken in the past year. Could it have just been a specific program you were running with a tight loop that didn't have any yield points? If so, that's not really unique to Julia.

I'd also be interested in your workload that was generating lots of seg faults (oom makes some sense if working with large data since Julia's runtime does add an unfortunate amount of memory overhead.

JET.jl does a surprisingly good job of statically checking julia type errors as well as other classes of errors using only type-level code analysis.

https://github.com/aviatesk/JET.jl

It does catch method ambiguities like those shown in this blog post:

  julia> using JET
  
  julia> f(x, y::Int) = x + y
  f (generic function with 2 methods)
  
  julia> f(x::Int, y) = x - y
  f (generic function with 2 methods)
  
  julia> g(x, y) = f(x, y)
  g (generic function with 1 method)
  
  julia> @test_call g(1, 2)
  JET-test failed at REPL[13]:1
    Expression: #= REPL[13]:1 =# JET.@test_call g(1, 2)
    ═════ 1 possible error found ═════
    ┌ @ REPL[12]:1 Main.f(x, y)
    │ no matching method found for call signature (Tuple{typeof(f), Int64, Int64}): Main.f(x::Int64, y::Int64)
    └──────────────
  
  ERROR: There was an error during testing

One alternative you could use is nix. It works as a package manager even when not running NixOS, and the software is generally up-to-date in the unstable channel (which most people use as far as I can tell).