Greetings
                                        Committers and Contributors,
                                        
                                        
                                        I am super excited to see
                                          the starter project moving
                                          forward after a little
                                          standstill. There has been
                                          some great progress made
                                          lately! New contributors and
                                          committers are on board. We
                                          now have a simple UI
                                          available at 
https://start.jakarta.ee that
                                          generates a simple project for
                                          Jakarta EE 8, Jakarta EE 9.1,
                                          and Jakarta EE 10. The
                                          feedback I have received from
                                          the community when demoing it
                                          has been 100% positive.
                                        
                                        The UI uses bare-minimum
                                          archetypes to generate the
                                          code. The next steps would be
                                          to add support for runtimes
                                          and possibly explore creating
                                          a CLI as an alternative to the
                                          Web UI.
                                        
                                        
                                        In addition to the UI,
                                          there are also several
                                          archetypes that generate more
                                          extensive examples being
                                          worked on. Since everything is
                                          based on archetypes, adding
                                          these and potentially other
                                          archetypes created by the
                                          community should be fairly
                                          straightforward.
                                        
                                        
                                        The archetypes for EE 8,
                                          9.1, and 10 could be
                                          mashed together as one with
                                          the conditional logic inside
                                          the archetype. I am not sure
                                          if this is the right thing to
                                          do, though. 
                                        Keep in mind that as we go
                                          forward with EE 11, 12, 13,
                                          ... the older versions won't
                                          need much attention.
                                          Sometimes, a little
                                          duplication is favorable over
                                          adding another branch in the
                                          logic (even if it is just
                                          another if-statement...).
                                        
                                        
                                        
                                          The option of creating a
                                            server-based solution to
                                            generate the starter
                                            projects is still an option
                                            if someone wants to pursue
                                            this. It is always good to
                                            have options.
                                          Personally, I think the
                                            approach to base the starter
                                            on archetypes is a better
                                            and more flexible way to go.
                                            The only server needed is
                                            Maven Central, and that is
                                            already there and not our
                                            problem to maintain. And it
                                            provides the option for
                                            developers to consume the
                                            archetypes directly, via our
                                            UI, potentially a CLI, or
                                            directly in IDEs.
                                          
                                          
                                         
                                        Ivar
                                        -- 
                                        
                                          
                                            
                                              
                                                  Ivar Grimstad
                                                  Jakarta EE Developer Advocate | Eclipse Foundation
Eclipse
                                                      Foundation - Community Code. Collaboration.