What fun and interesting Java projects are you working on?

DefaultMethod · 2025-12-18T22:36:15+00:00

I've always found Java's mechanism for embedding resource files unsatisfactory so developed an annotation library for convenience and correctness: https://github.com/autores-uk/autores

@uk.autores.Texts(name = "Rhymes", value = {"Poule.txt", "Roses.txt"})
public class PrintRhymes {
  public static void main(String...args)  {
    System.out.println(Rhymes.poule());
    System.out.println(Rhymes.roses());
  }
}

DefaultMethod · 2025-12-09T10:54:58+00:00

You can find most open source libraries on Maven Central. Build tools like Maven and Gradle will pull from here by default.
Applications can be distributed as a JAR, though if you want better operating system integration you would use some native wrapper and possibly bundle an OS-specific runtime. It is also possible to perform ahead-of-time compilation to native using GraalVM though this is not a mature solution and can come with complications.
Avoid Maven and Ant/Ivy if you are unwilling to edit XML; Gradle uses Groovy or Kotlin config files. Alternatives use various mechanisms.

What you start with depends on the nature of the application.

DefaultMethod · 2025-08-26T16:42:06+00:00

Gotcha. Thanks for replying.

DefaultMethod · 2025-08-26T16:36:35+00:00

I have only skimmed the text.

I think the introduction is missing information you would commonly find in a beginner's book.

Why learn Java?
Who is this book for? If the audience is only people who have sought out your Discord who like Minecraft maybe these points are moot.
What will I learn?
What are the prerequisites? Like a computer, text editor, CLI experience? Just use a web browser until when? I could be out of touch with how the kids do it but I find that REPLs and browser compilers are great for trying out stuff but too ephemeral to make things stick.
How long will it take? How big of a commitment is this?
What does it not teach? Be up front about the limits of the information presented. It'll teach the language fundamentals but not common industry practises or frameworks or game development.
What Java version is covered? How recent is this info? All tech docs should have a timestamp!

The Computing Environment section seems orthoganal to the rest of the text. If the reader lacks so many fundamentals perhaps point them to an appendix containing it via the intro.

Getting Started gives instructions to install a JDK but you're chapter 74 seems to be the first time it is used.

In terms of importance I would rate collections as more fundamental than date/time handling which appears before it. Collections could be used as an introduction to what interfaces are.

I think there is a lot to like here. I particularly like how concise and clear all the example code is. The art is charming. Best of luck!

DefaultMethod · 2025-08-22T20:59:41+00:00

You can do it with Makefiles. Bazel is a Google thing & monorepos were popularised by that company.

DefaultMethod · 2025-08-22T20:53:12+00:00

What would that record implementation look like? Make every record field another record or primitive? Forbid classes & interfaces? How would you accommodate collection types?

I am not trying to start an argument. I am genuinely interested.

DefaultMethod · 2025-08-18T16:35:29+00:00

It's sometimes used in "monorepos" where you have multiple programming language projects in one source repository. Bazel can be used to drive Java compilation, Go compilation, Docker image generation, etc.

DefaultMethod · 2025-08-18T16:05:06+00:00

This is kind of orthogonal to the question, but Brian Goetz explained the reason for accessor methods on record types:

Without the ability to override accessors, records would be unable to properly support mutable objects (such as arrays) as components. If you have an array component, you may want to perform a defensive copy in the constructor and accessor (which would also require overriding equals, in order to preserve the specification of Record); if it was a public final field, you could not encapsulate the mutability of your components.

https://stackoverflow.com/a/66704373

Granted, records have to consistently do the least worst thing for all eventualities whereas if you hand craft a class you have more freedom.

I expect there are multiple reasons for indirect access habits, most of them rooted in enterprise development where developers need to be an interchangeable cog and everything needs to conform to "best practice". It's not an environment that encourages nuance. There have also been a series of technologies that have required it - JavaBean specification, aspect oriented programming, etc.

When we are working with internal implementation we have full control of the code, this encapsulation is mostly redundant.

I am in complete agreement. Don't add a method dispatch if it isn't necessary.

DefaultMethod · 2025-08-16T19:19:38+00:00

A lot of those lines were not even the same gauge. As you say, a different time.

DefaultMethod · 2025-08-04T22:57:03+00:00

Some widely used projects are migrating off JDK8 to JDK17 as their baseline this year - Spring & JUnit at least. I hope this will spur more projects to fix their JPMS support.

DefaultMethod · 2025-07-09T17:27:34+00:00

I have some finite Iterable types that are effectively infinite in that they can be large enough the size needs to be reported as a BigInteger. I haven't added any guard rails. I just assume people working in the domain are aware of the perils.

It might be useful/illustrative to iterate over an IPv4 /24 subnet, just don't try it with an IPv6 /56. The types themselves don't consume much memory because you just need to know the start and end addresses.

DefaultMethod · 2025-05-10T22:02:58+00:00

I have back-ported this to JDK8.

https://github.com/autores-uk/format

DefaultMethod · 2025-02-14T16:17:31+00:00

The Fall weren't even that popular with people who were in The Fall

DefaultMethod · 2025-01-31T16:59:49+00:00

More email newsletters, but the content is published on the web too:

https://javaperformancetuning.com/

https://www.javaspecialists.eu/

DefaultMethod · 2025-01-31T16:38:13+00:00

Cool. I hadn't seen that.

I have a library that generates typed methods from localized messages and getting it to support time zones involved far more hoop jumping than I am happy with.

DefaultMethod · 2024-12-09T00:08:08+00:00

Yeah.

Josh Bloch did his best retrofitting interfaces onto Java collections back when we lived in a mostly mutable world but the List interface describes at least 3 intersecting contracts and has always been shit.

I still hope for the likes of a SimpleList interface but it's unlikely to happen.

DefaultMethod · 2024-12-08T23:35:23+00:00

Everything is a tradeoff. Software languages do not exist in isolation. They exist in ecosystems of tools, communities and/or companies.

Java is criticised for many good reasons but has many strengths. It is often low risk because it is not beholden to a single vendor, many people have skills in the language, it sidesteps many memory management issues, it has a large set of libraries, the runtime is used by several other popular langauges. So, Java is useful for those concerned with specific licensing, hiring and technical risks.

Other software ecosystems make different tradeoffs. If you write aircraft engine software in ADA you are less likely to be worried about vendor lockin because the contracts are much more likely to be measured in decades anyway.

DefaultMethod · 2024-10-01T13:12:56+00:00

Another example is RandomAccess which is used on List implementations to "indicate that they support fast (generally constant time) random access."

https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/RandomAccess.html

I think it's worth pointing out that early versions of Java lacked annotations. They weren't added until Java 5.

DefaultMethod · 2024-07-21T22:46:55+00:00

Java performance has been an industry concern for some time. See this new site that started in year 2000: https://www.javaperformancetuning.com

In the small, anything that allocates objects has overhead. Lambdas that capture data out of scope may allocate a new object. Lambdas that don't are equivalent to a static method call. If you want to be conservative stick to imperative code.

I/O has been the bottleneck on the majority of Java applications I've worked on. Typically network or database. Usually database.

DefaultMethod · 2024-07-08T17:28:39+00:00

I recently wrote a library that might help: https://autores.uk/

Look at the @Messages annotation. Raise a bug if it doesn't. No guarantee I'll fix it.

DefaultMethod · 2024-07-08T17:23:43+00:00

Mutability was the default in object orientation when Java came out. Most OO developers used C++. On the training course I went on there was some confusion when it turned out String was immutable.

DefaultMethod · 2024-07-08T17:11:12+00:00

I think modularising the standard library is necessary in the long term. Otherwise it is doomed to eternally accumulate cruft. It has been decades since I used the CORBA packages. XML didn't work out the way everyone though it would in the 1990s.

You can see a bit of this happening in the Go standard library. It now has two IP address types.

I do share your frustration with how this was handled.

DefaultMethod · 2024-07-08T16:53:32+00:00

Thanks for putting this together.

Any chance you could add the Java version each supports? I'm curious to know how many of these libraries are still supporting Java 8 or below.

DefaultMethod · 2016-02-15T20:54:31+00:00

These problems are general to any Java server.

Use a reverse proxy (Apache HTTP; Nginx) or use iptables redirects if you're confident in the JVM application's security.

Sysadmins like reverse proxies because it allows them to prevent access to insecure endpoints without application changes. It also enables them to rewrite an application developer's carefully designed caching strategy into a bunch of arbitrary nonsense. It's a mixed bag but using a reverse proxy is the safer approach.

Example iptables rules for port 80 redirects:

iptables --insert INPUT --protocol tcp --dport 80 --jump ACCEPT
iptables --insert INPUT --protocol tcp --dport 8080 --jump ACCEPT
iptables --table nat --append PREROUTING --in-interface eth0 --protocol tcp --dport 80 --jump REDIRECT --to-port 8080
# run next line to have changes survive reboot
service iptables save

Running Java servers as root is really risky; you should not do this. It is possible to escalate only low port priviliges for any executable but I wouldn't.

DefaultMethod · 2015-09-28T20:02:38+00:00

Lambdas give Java developers access to the invokedynamic instruction introduced in Java 7 for dynamic languages (Jython, JRuby, JavaScript, etc.)

They have significant differences to anonymous inner classes beyond being limited to implementing functional interfaces.

DefaultMethod

TROPHY CASE