I believe this is a
                                worthy discussion, perhaps also
                                ultimately for the Platform mailing
                                list.
                             
                            
                            
                              I think we should try
                                very hard to stick to mirroring
                                certification results. Otherwise we
                                enter a potential minefield of fairness,
                                avoiding user confusion, potential
                                devaluation of certification, weakening
                                compatibility, etc. This is of course
                                especially acute as this is the official
                                starter.
                             
                            
                            
                              It would be good if
                                others could weigh in on this. On Slack
                                it was only myself, Scott, and Ondro
                                that chimed in at all.
                             
                           
                          
                            Let me raise
                              the question from Slack:
                              https://eclipsefoundationhq.slack.com/archives/C047MCS83FT/p1678788937498749
                              to the list here:
                             
                            Should the
                              Eclipse Starter for Jakarta EE project use
                              formal compatibility/certification/etc. to
                              guard use of the UI and underlying
                              archetypes, for a given combination of
                              runtime+profile+version?
                             
                            An alternative
                              might  be to allow someone working on a
                              particular runtime to “vouch for” the
                              usefulness of the function at a certain
                              level if they work on the PR. 
                            
                             
                            E.g. with Open
                              Liberty close to EE 10 compliance, I
                              wouldn’t expect Reza or one of the starter
                              project committers to go out of their way
                              to enable this, but if I personally (as an
                              Open Liberty committer) were to do the
                              work to enable this then maybe my PR
                              should be merged?
                             
                            Some more
                              thoughts:
                            
                             
                            Maybe there
                              could be an asterisk (*) or warning/caveat
                              about a runtime in such a
                              not-yet-certified state?
                             
                            If this is
                              going to lead to debates about what should
                              vs. shouldn’t be allowed though then
                              perhaps it wouldn’t be worth it.   A nice
                              thing about keying off formal
                              certification is that we’ve already agreed
                              to what counts as compatible. 
                             
                            I do see some
                              potential for user confusion if
                              uncertified runtimes are enabled via the
                              starter. 
                            
                             
                            But the
                              counterargument is to consider the case
                              that we’re very far along on the way to
                              certify against EE 10, we’ve got a lot of
                              useful function and this convenient
                              starter… let users take advantage of it. 
                              They don’t care that we’re disputing three
                              TCK test methods at this point.
                            
                            And assuming
                              the runtime is in some kind of beta /
                              early release then presumably there’s
                              going to be a suitable “warning” implicit
                              in the non-final version of the particular
                              runtime.
                             
                            Anyway,  I
                              could argue more with myself but let me
                              send this out for discussion first.
                             
                            Scott Kurz