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.