I recently needed a simple example of an SPI implementation I could send around as copy and paste template. After some looking around I found some tutorials, but most of them were rather heavy in the implementation and are thereby loosing the point of being a simple extension system within the JDK.
In this blog post, I’m going to explain how you can make use of the Micronaut framework to organize your project code in such a way that you can externalize and modularize some of your @Beans. These beans can be used as “common” and can be shared between several projects.
This means that my content, or at least part of it, is still available if I need to migrate instances again.
I need to further refine the process, as media and emoji are hot linked. This was not my preference but I could not get my head around async await at 2am.
Last night I switched the method through which I import my mastodon toots from here into my #11ty blog.
It now pulls changes when a ci build is triggered using an external script, rather than during the render/build phase. It does this by generating markdown files with yaml frontmatter. The process creates a new commit which in turn triggers a full build of the site on the main branch.
In this article, we are going to talk about Java’s Service Provider Interface (SPI). We will have a short overview of what the SPI is and describe some cases where we can use it. Then we will give an implementation of an SPI for a practical use case.
It's early days, too early to be thinking this far forward. I can't get the idea out of my head, so i'm putting it out there for comment. With any luck this will help me to move onto the basics, such as actually implementing activitypub.
Are there other solutions I should be considering which would be better suited to the task? I've not implemented anything with OSGi or SPI directly so this area is quite new to me. SPI seems like it may work technically.
Would this make sense from an implementation standpoint? I'm not currently targeting native image; it will be a deployed service running upon an installed JVM. SPI seems much more lightweight than other solutions like OSGi, which seem like a sledgehammer with far-reaching design implications in comparison.
I'm in the process of building an #activitypub implementation using #java and #micronaut.
I'm considering options to make the platform "pluggable". The plan is to use something like SPI to load plugins from JAR files, allowing features to be added to customize the platform for individual needs.
Off the top of my head I'm thinking things like custom APIs or storage back-ends to do things which won't be included a (completely theoretical) core distribution.