i didn’t create this post in the general programming community.

This is JADEx post. get out of hier.

This is JADEx post. get out of hier.

This is JADEx post. get out of hier.

By that logic, every object-oriented language is just Smalltalk diluted with something. Dilution isn’t degradation. Sometimes it’s just called adoption.

Thank you! I’ll keep working to make JADEx a compelling option for teams in exactly that situation. Your interest and any feedback along the way means a lot.

JADEx will be maintained for as long as I’m alive, so I suppose I’d better try to stick around as long as possible.

Seriously though, I’d love for more people to get involved and contribute to the project. The more contributors it has, the less that concern applies. If JADEx’s direction resonates with you, any contribution (whether it’s code, money, feedback, or just spreading the word) is genuinely appreciated.

JADEx is a solution designed to enhance null-safety in Java. Its key advantage is that existing Java developers can gain null-safety and immutability without any learning curve. As a result, compared to migrating to Kotlin, JADEx offers a much more cost-effective way to significantly improve the stability of the legacy Java codebases that many companies continue to operate.

In addition, JADEx provides immutability, allowing developers to strengthen immutability without the verbose use of the final keyword.

Let me correct a misunderstanding. JADEx was created as a Java superset language to strengthen Java’s insufficient null-related type system. In JADEx, Java’s reference types are assumed to be non-null by default, and through the nullability static analysis results provided by JADEx, developers can explicitly choose to mark types as nullable. Because of this, there is no problem using null-safe access operators and the Elvis operator.

To summarize:

• Java: All types are nullable; there is no non-null type. Therefore, Elvis operators and null-safe access operators cannot be used.
• JADEx: Both nullable and non-null types exist. Therefore, Elvis operators and null-safe access operators can be used.

I believe that if a company is a large corporation, it should provide financial support and take responsibility for large-scale bug reporting.

Okay. You must realize it is weird to use the term “development team” to describe a one person side project. Also, are you willing to disclose to what extent and which models were used to create this project?

JPlus is an open-source project. Anyone can review the implementation details on GitHub: https://github.com/nieuwmijnleven/JPlus

It’s true that the project is still in its early stages and not very large yet. I believe that with consistent effort, the number of people contributing to this project, as well as those who want to use JPlus, will grow over time. Thank you.

Thank you for your opinion.

I hope you’ll continue to follow and support the growth of JPlus!

Thank you for the excellent question.

1. How does JPlus handle null safety in Java library interfaces?

• JPlus is currently implemented at the MVP level. Therefore, all Java library interfaces are treated as non-null by default. As a result, developers need to manually check for nullability when interacting with Java libraries.

• When referencing Java library objects, always declare the variables as nullable (type?) and use the null-safe operator (?.) when accessing them to prevent null pointer exceptions (NPEs).

• In future implementations, we plan to leverage nullability annotations in Java library code to add null-checking logic. However, since not all Java libraries include such annotations, developers will still need to manually handle null checks. The same applies to Kotlin: platform types are used, so developers are responsible for performing null checks.

2. If nullability information is a type metadata extension for compile-time checking, does that inevitably break on library interfaces when I create both library and consuming app with JPlus?

• In the current JPlus MVP, when converting to Java code, nullability information specified in the JPlus files is not converted into @Nullable/@Nonnull annotations.

• Therefore, using static analysis tools that rely on these annotations may cause issues at compile time.

• This feature will be supported in the next version, which will include conversion to @Nullable/@Nonnull. Thank you for your valuable feedback.

Finally, for faster responses, please post any future questions on the JPlus GitHub Discussions page: https://github.com/nieuwmijnleven/JPlus/discussions.

Didn’t I make myself clear? If you find it uncomfortable because you think it’s an advertisement, just move along. What do you think you’re doing? Look at the project I’m working on before you speak. You have no idea how much effort has gone into it. Calling it a scam is truly absurd.

The idea might be enough. Lots of companies running legacy code would be interested in this idea since it would make maintaining/patching it easy.

Thank you for your response. I will take your valuable feedback into careful consideration.

First of all, thank you for your interest in the JPlus project. I also apologize if anything I said earlier came across as rude.

The point I think was misunderstood is that, while the content of the posts is similar, the links they contain are different. To clarify once again, the link in this post directs to the JPlus GitHub repository, whereas the link in the post you mentioned points to the JPlus blog on Hashnode. Please check again.

Yoy won’t find your target audience here on lemmy.

Instead you should look for companies that have open job/freelancer positions for maintaining legacy java code and pitch your project to them.

That’s a great idea. Thank you. However, I’m not sure if such opportunities would be available at my current stage.

Please check this post: Making your Java code null-safe without rewriting

Is this your first time here? The link in this post leads to the GitHub JPlus repository, while the other posts ultimately link to explanations on how to handle null safety using the JPlus IntelliJ plugin. Aside from the brief introduction, check out the additional links.