I still have fond memories of my 2013 Jolla, and I'm hoping that the 2026 Jolla will be just as lovingly crafted. Most importantly, Jolla is a company that seems to care about me, the user, whereas Apple and Google constantly treat me like a peasant that needs to be governed.

There is a reason why the Iranian government cannot activate internet and phones anymore. Once people can communicate again, they will count and document the true scale of events. Right now, it seems the Iranian government would rather give up on internet and telephones altogether than having anyone find out, which tells you just about how bad the situation is.

Also, this technique eliminates a number of worst-case scenarios and inefficiencies, which is a boon for any hash table user.

Kudos to the uv developers for creating such an amazing piece of software!

1. There may be people who cannot use/afford some software, although there is technically an infinite supply.

2. Collaboration becomes awkward. Either all contributors give up their rights (Open Source), or one contributor holds all the rights and the rest is being treated unfairly. The latter decreases the incentives to make software modular and reusable.

3. The resulting software typically gets worse due to some copyright enforcement mechanisms. For example, no closed source software will ever have a good debugger, because that would allow viewing and changing the source code.

4. It creates a power imbalance between software owners and software users. Nearly all software has to be adapted over time, but the software owner has a monopoly on performing such adaptations. The result is enshittification, surveillance, and basically a return to feudalism where daily life is governed by a small number of overlords.

5. It is not clear how to price software fairly, and there is also little incentive to do so.

6. My impression is that high-quality software converges to formal proof, which is AFAIK not copyrightable.

For all these reasons, I think it is time to consider a world without copyright on software.

To those that worry about salaries in such a world: Negotiate payment in advance (contracts, crowdfunding, bounties, ...), or get a job where software is created as a byproduct (consultant, researcher, tester, ...).

I suggest Microsoft follows Britain's example and leaves. The main difference is that we Europeans actually miss the Brits, whereas nobody would miss Microsoft and its shoddy products and business practices.

On a more serious note, I fully understand that the Digital Markets Act is causing Microsoft headaches. But I think this headache is well deserved. Big Tech has been building moats where they should have built bridges, and now our computing landscape resembles medieval Germany where everything was at the mercy of a few feudal lords. It is time to drive out those lords and reshape software in a way that empowers, not enslaves.

Seeing Greenspun's tenth rule [1] in action again and again is one of the weird things we Common Lisp programmers have to endure. I wish we would have more discussions on how to improve Lisp even further instead of trying to 'fix' C or C++ for the umpteenth time.

[1] https://en.wikipedia.org/wiki/Greenspun%27s_tenth_rule

[1] https://github.com/marcoheisig/Petalisp/blob/master/code/cor...

> Nevertheless, we have implemented (on a single-processor system, the Symbolics 3600) an experimental version of Connection Machine Lisp with lazy xappings and have found it tremendously complicated to implement but useful in practice.

I think there is a moral here: Don't hesitate to experiment with crazy ideas (lazy xappings), and don't be afraid to openly talk about those experiments.

After eight years of development, I can definitely confirm that lazy arrays/xappings are tremendously complicated to implement but useful in practice :)

- The parallel garbage collector is now part of SBCL, but not yet the default. Enabling it is attractive, though, because it has roughly twice the throughput.

- The SBCL maintainers used the parallel GC as reason to make SBCL's memory management overall more modular. This process is still ongoing, but experimenting with different GC strategies on SBCL has never been easier.

- Another GC is already in the works that has virtually zero pause times. Once this is merged, we can finally bury that old myth that Lisp systems stutter (if it hasn't already been buried by the presence of video games written in Lisp, like Kandria)

The parallel GC is an amazing achievement by Hayley Patton. We SBCL users cannot thank her enough for her outstanding work!

Petalisp author here - this ELS paper is just a preview. I'm also preparing a 160 page document (for my PhD) that will explain everything in more detail. I'll post on HN when it is available.

There is also a recording of my ELS talk on Twitch: https://www.twitch.tv/videos/2138821711?t=00h40m35s

- Starting from April 1, German adults can legally possess a certain amount of weed (25 grams on the move, 50 grams at home), and they may consume it unless they are within 100 meters of a school or kindergarten.

- This is just the first stage of that law, where the only way to actually obtain weed (other than for medical purposes) is to grow it yourself, or to form a collective of growers. Either way, the maximum number of plants per person is three. Commercially trade of weed is planned for later, as a second stage of the law.

- While this law legalizes weed for adults, it further prevents access for minors. The law raises the penalty for selling weed to minors to a minimum of two years in prison, and people that grow their own plants must ensure that minors cannot access them. People aged between 18 and 21 are only allowed access to weed with a THC content of less than 10%. The reasoning behind all this is that weed severely impairs the brain development of young people.

- Driving while under the influence is still a crime.

- The stated goal of this law is to eliminate the black market and to stop the growing trend of minors smoking weed. A review is scheduled in 18 months, determine whether the law in the current form achieves that goal or whether it has to be tweaked further.

This law is obviously a compromise between all the parties of the German government, EU law, scientific consensus, and practicability. What I like about the law is how carefully it weighs health issues and individual liberty. All the limits (legal age, grams of possession) have a solid scientific basis.

This is no special casing. Most of that code will also be used for the distributed parallelization. I agree with your remarks on hybrid MPI+OpenMP, and, in fact, Petalisp doesn't use shared memory anywhere, but always generates ghost layers and explicit communication.

> I will also say that it feels a bit weird to call something "peta-" and "HPC" if using more than one socket is relatively far off into the future. For the randomly-wandering PhD students out there, it would be nice to tell them this up front in the Readme :)

I can do that. But let me explain the rationale for naming Petalisp this way: I wanted to create a programming language that is novel, and that has the potential to scale to petaflop systems. And I wanted to create a robust implementation of that language. I think I have achieved the former part, but the latter simply takes time.

Final remark: Good HPC practice is always to get single core performance right, then getting multicore performance right, and then scaling up to multiple nodes. Anything else is an enormous waste of electricity.

About the required hardware - anything that runs SBCL or CCL can also run Petalisp.

As you may have seen on the commit history, a lot of exciting things have happened over the last few months. However, there are also a few stupid performance bugs left, so I am delaying the release of any performance numbers until those have been fixed. Otherwise, I fear that people will simply misinterpret the results.

Nevertheless, I can already state that the single-core performance of Petalisp programs is exactly like that of a C program - simply because Petalisp compiles its programs to C when possible. (Although I also have that long-term agenda of using sb-simd to reach that performance in pure CL some day.)

In addition, Petalisp is quite good at automatically parallelizing programs, and we already have most of the infrastructure for distributed and heterogeneous computing in place.

I will write a more detailed post for the HN crowd once I have reliable performance numbers and once I finished writing the documentation.

Feel free to ask me further questions.

Here is my take on the situation: The problem is that the current government consists of three very different parties (which was the only viable option for forming a government without the conservative climate disaster that is the CDU/CSU). One of these three parties, the FDP, is currently losing popularity because they essentially promised that fancy technology will solve all our problems (take note HN!), but that bluff got called now that they are part of the government. The FDP is quickly losing voter support, and entered panic mode. Unfortunately, the only voter base they can quickly tap into are petrolheads and people that don't like when things get "verboten". The FDP runs the ministry of transport, and used that influence to stall legislation for the entire EU. The other parties cannot really object, or our government would fall apart.

I can only personally apologize to all other EU nations. A party with about 5% popularity is holding our government hostage.

The only positive thing is that these people cannot really decide about the law in 2035, only about the law today. I hope the climate movement will grow stronger, and those people and their policies will be history much sooner.

Also, it shows that Maxima has been in use for a very long time, and maintained by very bright people. I have yet to encounter a bug in Maxima. And I have already encountered plenty of bugs and inconsistent behavior in SymPy.