Skip to main content

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index] [List Home]
Re: [starter-dev] Starter archetypes / GUI / Issue #67

Unfortunately with the popularity of the Spring initializer, I am afraid we have no choice but to have a UI. I do believe at least initially we need to focus on a simple UI. Certainly trying to present a “components” view of Jakarta EE is something we should prioritize lower at this time. I think it’s best to just evolve features including the UI over time. Part of the reason the project was stuck for so long is a lot of analysis paralysis around requirements and the UI. I think we should remain in a different gear now and focus a bit more on delivering working releases, even if incremental.

I do have to say that personally I believe a command line is all you need because the array of options indeed could be quite small. That’s why I would prefer we kept a mindset of being somewhat agnostic of a UI. Luckily as a side effect the IDE experience also remains nice as most IDEs have pretty good support for Maven Archetypes. It’s fairy easy to support all three pathways equally without too much work.

With regards to Gradle, I spoke with Bazlur and we feel we could easily do this without too much hassle using Maven to Gradle converters behind the scenes. The plan was to look at this once we have delivered a few more solid releases.

I should add that I am not necessarily totally against having a more minimal project generation option. What I am having trouble visualizing is what exact content is worth putting into a minimal option. Just a pom does not feel like it’s worth the effort because of the nature of Jakarta EE. Perhaps looking at what Ivo has might help. I will try to do that analysis by the end of this week. As such, adding a minimal option won’t “hurt” anything except for maybe a bit more code to maintain for us. Perhaps it can be done with a small amount of code. I’ll try to think about that once it’s a bit clearer what could be generated that makes reasonable sense.

I definitely feel strongly that a reasonably complete, working REST CRUD example is very important to have in the starter experience to increase adoption with new users for sure. There is already plenty of data points to support this need and plenty of precedent. Hopefully some of the folks that can already see that will chime in too.

From: starter-dev <starter-dev-bounces@xxxxxxxxxxx> on behalf of Edwin Derks <ederks85@xxxxxxxxx>
Sent: Tuesday, May 3, 2022 4:05 AM
To: starter developer discussions <starter-dev@xxxxxxxxxxx>
Subject: Re: [starter-dev] Starter archetypes / GUI / Issue #67
Hi Ivo (and all),

Thanks, I'm also glad to see you joining this initiative. I know that it is your cup of tea from both a technical and teaching perspective, so your input is very much appreciated!

I'm still struggling with the GUI for generating Jakarta EE based projects, based on archetypes or not. It is indeed dead simple as you stated, because bootstrapping a Jakarta EE project is that simple. A Maven pom.xml file with the necessary provided Jakarta EE dependency, the required directory layout for Maven and optionally some basic files like persistence.xml and beans.xml would already be sufficient. Teaching people that this is all that's required to run on a compatible application server of their choice and which one: that's imho where the struggle is. New users often don't understand this concept ootb, and certainly not the value and benefits of this. They expect to click an interface, get a file back and be able to run it. Therefore: I get comments like:

- Jakarta EE is bad because it doesn't have a GUI like Spring or Quarkus. My option: no it doesn't because it doesn't necessarily need it other than the dead simple interface like you provided. Or the MicroProfile starter. You don't have to select components for Jakarta EE compatible projects.
- Jakarta EE is bad because it doesn't have (sufficient) Gradle support. My opinion: no it doesn't because it doesn't necessarily need it other than that the exact same build artifacts are generated by a different tool.

So getting to the question of the backlog items we want to process: to what extent do we want to adhere to the user's desires via command line, GUI and tooling support? I would suggest that we create a product vision for the starter that describes what we include, and want to teach people to use the right way, the Jakarta EE way. Anything else can be explained in a FAQ or tutorials or whatever why support for certain desires is not going to be implemented.

What are your thoughts?


On Tue, 3 May 2022 at 08:59, Ivo Woltring <ivo@ivonetnl> wrote:
He Edwin, 

Good to hear from you!

I can only say… I agree with your three points :-)


On 3 May 2022, at 08:08, Edwin Derks <ederks85@xxxxxxxxx> wrote:

Hi all,

I like the initiative of this separate starter project and mailing list, separated from the usual Jakarta EE mailing list discussions. I don't have all the answers to the discussions yet but would like to share my two cents to participate:

- we have users that would like to see IDE and command line usage, and we have users that want a UI to generate a project. Why not both?
- using archetypes is to bootstrap a project indeed, with minimal content for a certain purpose. Generating a full fledged demo project from an archetype feels like stretching the concept, and begs the question: why?
- I would advise not to overdo and overvalue the use of archetypes. Having separate ones for certain purposes (is the cut-off point a major Jakarta EE version?) feels legit, is it really that much of a burden regarding maintenance?

I'll also have a look at the content and project and see what I can come up with.

Kind regards,


On Mon, 2 May 2022 at 22:01, Reza Rahman <reza_rahman@xxxxxxxxx> wrote:

I'll take a look and share my thoughts on what you have.

I suspect the primary issue is the amount of generated code and the fact that you might be largely a solo effort and this effort already needing to collaborate between a number of committers and contributors. For solo efforts with very minimal archetypes the complexity that arises from code duplication and needing to maintain multiple archetypes and repositories is less of an issue. I think if you explore the current code base a bit more, you'll see why a simple change like adding a new runtime, fixing a bug or making enhancements across needlessly duplicated code would be a headache across a distributed team.

It also sounds like the command line and IDE usage as opposed to UI usage may not be a primary concern for you. The reason we went the Archetype route (which was not the original direction) is to better enable command line and IDE usage. Having fewer Archetypes to navigate makes the command line and IDE pathways easier to use and document.

One of the prime target audiences we have been putting in efforts towards is newcomers to Jakarta EE (hence For these sorts of folks there is definite value to a compete working but still relatively small example that showcases the power and simplicity of the platform. This is a primary use case for Archetypes ( and there are plenty of examples of this in the Apache Archetype catalog. Certainly this is what we do for our Azure Archetypes ( and it is very much appreciated by newcomers.

That said, another use case is definitely minimal archetypes that just generate a POM. The question is whether that's a valuable model for Jakarta EE. It certainly makes clearer sense for something like Spring, Quarkus or even MicroProfile where the POM itself is not so simple to compose.

With regards to the items on the issue list, they are quite dated and probably should be thought of as long term wish list items at this point rather than an actual committed roadmap. As we begin to tackle those after we work through the roadmap items there are higher levels of commitment on delivering (, we would certainly evolve, perhaps logically in the direction of multiple Archetypes. I think for now focusing too much on those does not make sense yet (as opposed to say creating a UI, supporting more popular runtimes or adding support for Jakarta EE 9.1).

For GlassFish questions, please feel free to reach out to the GlassFish alias: Most folks here are not GlassFish committers unfortunately.

On 5/2/22 3:03 PM, Ivo Woltring wrote:
The thing is I have maintained a couple of archetypes the last couple of years and I have chosen to do that in separate repositories because of the ease of use, maintaining and ease of creating new ones. My post processing script is very simple and always the same. 

@Reza you asked for code...

The code for these archetypes can be found here:

And they are all presented (GUI) here:

I hope that is enough of a demonstration of giving clear names and easy code. 

Why would having multiple repositories make maintaining something more difficult? I do not see that at all. If you need to change something for a specific archetype you only have to do that for that archetype right? No other archetypes needs to change. Also if you write a GUI like mine you actually have to document less as the choices you have are already clearly defined in the GUI. The GUI is dead simple because all the archetypes follow the same routine but with a different combination of tools. The telling names say it all.

So in my experience it is way easier to maintain a very simple archetype than to maintain a difficult one. The more the post processing script has to do the more difficult it will become. Taking versions / incompatibilities / different examples / etc. into account.

Right now I am creating an archetype for Glassfish 6.2.5 with JakartaEE 9.1 and Docker.
That is the only thing I want in that archetype. It is almost trivial for me to make a new one based on another example I already have or update that one to the new version, but it is not as trivial for me to create a PR on the official repo and that is why I haven’t yet.

I see a lot of requests for examples in the issue list ( The more examples you are going to put in the more exception flows (lots of if statements) you need to write if you want to jam that al into one repo. It is fantastically easy to create all those examples in separate archetypes and maintain them as they grow or need a new version. 

On another note. Should a fully fletched demo be put into an archetype? If I have to remove 80% of the code every time I need to start a new project I will not use it. How about you? Should examples not be tutorials with a repo attached?

Archetypes are there to generate a specific starting point for developers right? I know I am new to this discussion but if the goal is newcomers isn’t an archetype not a strange approach? I am not trying to be difficult but I honestly don’t understand these choices. I think an archetype should help developers to start coding, not to give a demo.

BTW why do we not have official Glassfish docker images anymore?

On 2 May 2022, at 15:21, reza_rahman@xxxxxxxxx wrote:

The GitHub Actions Pipeline in the current project is already designed to test out all the current options per check-in or PR. Have you had a chance to look at that? Whatever the project structure, it would be important to have such automation in place. I would say these needs are basically the same no matter what the approach.

As I alluded to elsewhere, I personally have a hard time understanding what the value proposition would be for a very basic Archetype for Jakarta EE. Because of the nature of Jakarta EE, the essential Maven structure is always rather simple. Would it really differ very much from the Archetypes that Apache already has in the catalog? Other than the Maven project structure and POM, what other generated code would be included if any? A Servlet or JSF page? Is that really important these day? A REST endpoint? Is that really different enough from what’s there right now?

Anyway, a relatively complete code example of what would be generated would really help me understand (and probably others too). How do you think one could get that? Would it be possible to issue a draft PR? Is it already available to see? That would also help clarify the value for a possible separate Archetype (that’s what I had in mind for JSF as the generated code including the unit tests and index page would likely vary too much from the current REST CRUD example).

From: starter-dev <starter-dev-bounces@xxxxxxxxxxx> on behalf of Ivo Woltring <ivo@xxxxxxxxx>
Sent: Monday, May 2, 2022 3:07 AM
To: starter developer discussions <starter-dev@eclipseorg>
Subject: Re: [starter-dev] Starter archetypes / GUI / Issue #67
If you make an archetype that can do a lot of things and configure a lot then it becomes more difficult by definition.
How do you test such an archetype with all its options? Generate all combinations with every change and see if it still works?

DRY is in my opinion not always the best way to go, but I see your point.

What of a compromise?

A bare bones project with only the maven project and Dockerfile of choice and one with all the demo thingies and options in it.
One for new blood to learn and one for those who just want a new project so they can start jamming?

On 1 May 2022, at 08:03, reza_rahman@xxxxxxxxx wrote:

So I had a quick side chat with some of the folks that develop our various Maven Archetypes for Azure just to validate what I had been planning. They confirmed that this is not just doable but very normal for what is typically done in post-processing scripts for non-trivial Archetypes. Indeed it is rather simple compared to much more advanced capabilities like in this example script they shared: This is the use cases that post processing scripts are for after all as opposed to the more basic Archetype templating features.

Still, I am happy to actually prototype out what I had in mind so folks here can take a look and hopefully see for themselves how much not a big deal this really is.

Now, I am not saying that if the generated project varies too much in reaction to parameters that there isn’t a sensible case for creating a separate Archetype. For example, I can see a generated JSF CRUD project being sufficiently different from the current REST CRUD generated code. But fairly minor variations for Jakarta EE versions and target platform? I think that’s no big deal at all. Even the relatively simple Payara Micro Archetype handles Jakarta EE versions just fine as parameters:

From: reza_rahman@lycoscom <reza_rahman@xxxxxxxxx>
Sent: Saturday, April 30, 2022 8:14 AM
To: starter developer discussions <starter-dev@xxxxxxxxxxx>
Subject: Re: [starter-dev] Starter archetypes / GUI / Issue #67
I have to be honest, I really don’t see why multiple Archetypes would be any easier at all for anyone.

From one Jakarta EE version to another, the only things that would change are Jakarta EE dependency versions, Java SE versions, runtime versions and package names. Those could easily be expressed as variables in the source and filled out using templates in the Groovy post-script (Groovy even has built-in template engines for this). The user simply needs to specify the Jakarta EE version as an Archetype parameter. The Groovy post script can then easily replace a set of variables depending on the user input parameter. This of course in addition to the incremental file replacement technique we already have in the Groovy script. These simple techniques avoid needless complexity for the end user and code duplication while utilizing reasonable modularization.

Before going down the multiple Maven Archetypes road, I suggest taking a look at how that would work. It’s really quite simple, flexible and robust. I can dynamically generate just the Java/Jakarta EE package name for now to demonstrate the technique if you like. I’ll need about a weekend’s time to do that if this is a priority right now.

From: starter-dev <starter-dev-bounces@xxxxxxxxxxx> on behalf of Ivar Grimstad <ivar.grimstad@xxxxxxxxxxxxxxxxxxxxxx>
Sent: Saturday, April 30, 2022 2:03 AM
To: starter developer discussions <starter-dev@xxxxxxxxxxx>
Subject: Re: [starter-dev] Starter archetypes / GUI / Issue #67
We need to be able to support multiple versions of Jakarta EE at the same time. 
Support for EE 9 and EE 10 is crucial to get out ASAP. For this we have two options:

1. One archetype that supports the generation of multiple Jakarta EE versions
2. One archetype per Jakarta EE version

I think that 2) will get us there faster, and also reduce the complexity of the archetype. Thus apply WET rather than DRY. It would also be clear for the user which version is being generated by this being reflected in the maven coordinates. For example:



On Fri, Apr 29, 2022 at 9:41 PM Reza Rahman <reza_rahman@xxxxxxxxx> wrote:

Certainly a welcome idea, though hopefully not an "as-is" donation but a merge?

For example, are separate Archetypes really needed? I think for folks using it from the command line and IDE, just one Archetype would be far easier. As such, it is very easy to modularize Archetypes instead of exposing the user to the complexity of multiple Archetypes I think (you can hopefully see that in the code currently in the main branch and various runtime support).

On 4/29/22 3:06 PM, Ivo Woltring wrote:
Hi y’all,

A Couple of weeks ago I was triggered by the new archetype and have been playing with it.

The last couple of years I have maintained a couple of javaEE/jakartaEE maven archetypes and exposed them to the web:
Just now I saw the issue created by Ivar and that made me think.

If the community is open to it, I would love to join the effort and possibly ”donate" all my archetype related material.
It is already open source but right now under the Apache2 license. That is also open to change as I am the sole committer on these projects.

Please let me know what you think.

Kind regards,

Ivo Woltring.


starter-dev mailing list
To unsubscribe from this list, visit
starter-dev mailing list
To unsubscribe from this list, visit

Ivar Grimstad
Jakarta EE Developer Advocate | Eclipse Foundation Eclipse Foundation - Community. Code. Collaboration. 
starter-dev mailing list
To unsubscribe from this list, visit

starter-dev mailing list
To unsubscribe from this list, visit

starter-dev mailing list
To unsubscribe from this list, visit
starter-dev mailing list
To unsubscribe from this list, visit
starter-dev mailing list
To unsubscribe from this list, visit

starter-dev mailing list
To unsubscribe from this list, visit

Back to the top