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, someone has copied the source onto github[1] from the now defunct homepage. 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).

A few simple things:

- Air-dry clothes when possible instead of the dryer. - Only wash clothes when they're actually dirty. - Using cold water in the washing machine may help as well.

This is especially egregious as the whole idea of the language server protocol was proposed by Microsoft as a means of solving the problem wherein each editor has to independently implement IDE features for every language it supports (changes the number of implementations from n*m to n+m where n is the number of languages and m is the number of IDEs). Microsoft is now making it so that their product defaults to using a language server which cannot be used by any other IDE (without some owner of that IDE paying Microsft; the gnu project is not going to be paying Microsoft to allow using pylance with emacs).

There's significant dissonance here even by Microsoft's standard.

I find TIOBE's ranking to be the least helpful and most volatile of any of the language popularity measurements out there. A couple years ago, the Julia language team did a pretty good deep dive on just why that is.

<https://juliacomputing.com/blog/2019/09/tiobe-blog/>

Isn't org-mode part of emacs now? You don't require the FSF copyright assignment paperwork?

The author says he's happy with the performance improvements he made, but--even at the size where the Rust version performs best--he gets much less than a 2x speedup. After a couple months of effort, that's not a whole lot to show. This reads like a case study in why it's probably a bad idea to rewrite even when you think you have compelling reason for it.

Unfortunately this has been going at least as long as I've been aware of Onyx Boox products. E.g. https://www.mobileread.com/forums/showthread.php?t=277431. It's by no means an isolated incident.

If you take the benchmarks game as gospel, Julia is faster than C# in aggregate.

I'm 100% in agreement with you. Laws and ethics are only tenuously linked, and we must expect companies (made up of people) to act ethically first and foremost.

It's interesting watching you expressing that opinion in opposition to the Chinese government/Zoom getting a very positive reaction. When I expressed a similar sentiment about the Spanish government/Github a few months ago, the reaction was much more mixed[1]. I wonder if it has more to do with the parties involved or just changing opinions.

[1] https://news.ycombinator.com/item?id=21398271

EDIT: scrolling further down, the reaction to your comment is far more negative than I had originally thought.

The videos for the "European Lisp Symposium" appear to just be random 30-second clips. Am I missing something?

https://www.twitch.tv/elsconf/videos

I'm aware. To a large extent both regex-redux and pidigits are measures of the overhead of FFI for all non-C/C++/Rust languages. Rust is very cool in that one for actually using a regex engine implemented in Rust; definitely has my admiration.

I would love it if Isaac included LuaJit and pypy in the benchmarks game, but ultimately I get it; it's just one guy's project, and he doesn't want to spend the time to maintain it across the entire incredible diversity of programming languages/implementations[1].

To a great extent any "language" benchmark (for languages that don't compile to efficient machine code) is certainly a benchmark of the language's standard library. I'm not sure there's a way around that reality. Are there external Lua libraries that allow shared-memory concurrency? If so, it's probably worth opening an issue asking whether those libraries could be allowed[2]; it might just be that nobody has submitted a program making use of Lua shared concurrency.

[1] https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

[2] https://salsa.debian.org/benchmarksgame-team/benchmarksgame/...

The computer language benchmarks game[1][2][3] may be of interest here. It benchmarks C, Python, Javascript, and Julia, in several tasks involving FASTA input (regex-redux, k-nucleotide, and reverse-complement), but implementations are bespoke rather than relying on libraries. Relative timing is much more favorable for Julia in these benchmarks. Looks worse for Python outside regex-redux.

[1] https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

[2] https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

[3] https://benchmarksgame-team.pages.debian.net/benchmarksgame/...

In 2016 I lost access to some repos on bitbucket after a similar occurrence. I made the mistake of using my (student) university email account to register with bitbucket (it was the primary email account I used for everything at the time). At some point, my university apparently decided to use Atlassian services which completely disabled any ability I had to login to that account. I don't know if linking together all accounts under a domain is just the default behavior from Atlassian or if both this former employer and my university decided to screw people over, but either way it's a stupid situation and unsurprising at this point.

To be honest, I've never found the need for delegating a huge number of methods in my own work, but then I've never wanted to add a feature or field to something as complex and featureful as e.g. a DataFrame. What issues have you run into when using method-forwarding/delegation macros?

The nice thing about the Julia ecosystem is that people tend to be pretty willing to step back and define their methods in terms of an interface (Tables.jl in this case) which then allows code reuse without brittle delegation. Having to put so much effort into changing the structure of upstream doesn't seem ideal from a composability perspective though.

If using meta-programming to get "basic" features rubs you the wrong way, the language might just not be for you. In general, the Julia philosophy (as well as the lisp philosophy from which Julia descends) is that things which can be done efficiently using macros instead of being built-in should be done with macros. Language features are only for things that cannot be accomplished via metaprogramming. As far as actual implementations of method-forwarding macros, there's an implementation in Lazy.jl[1], and TypedDelegation.jl[2].

[1] https://github.com/MikeInnes/Lazy.jl/blob/0de1643f37555396d6...

[2] https://github.com/JeffreySarnoff/TypedDelegation.jl

There is.

https://github.com/alphapapa/matrix-client.el/

At the bottom of the article, it links to [1] as the original article. Could we please update the link?

[1] https://theconversation.com/would-you-notice-if-your-calcula...