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.