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.