On 6 Feb
                                                          2025, at
                                                          00:40, 'Ed
                                                          Burns' via
                                                          MicroProfile
                                                          <microp...@xxxxxxxxxxxxxxxx>
                                                          wrote:
 
From:
 microp...@xxxxxxxxxxxxxxxx <microp...@xxxxxxxxxxxxxxxx>
                                                          on behalf of
                                                          Reza On
                                                          Wednesday,
                                                          February 5,
                                                          2025 at 07:58
 m.reza...@xxxxxxxxx>
                                                          RR said:
Date: 
 
RR>
                                                          Just using
                                                          application.properties
                                                          is a good idea
                                                          indeed.
 
RR>
                                                          I am sure Ed
                                                          and Jared will
                                                          respond, but I
                                                          believe the
                                                          idea here
RR>
                                                          is to allow
                                                          both Jakarta
                                                          EE and
                                                          MicroProfile
                                                          to evolve
RR>
                                                          independently
                                                          in accordance
                                                          with their own
                                                          needs and also
RR>
                                                          collaborate
                                                          when best seen
                                                          fit.
 
Indeed,
                                                          doing that
                                                          now.
 
From:
                                                          'Roberto
                                                          Cortez' via
                                                          MicroProfile
                                                          <microp...@xxxxxxxxxxxxxxxx>
                                                          RC wrote:
 
RC>
                                                          A few comments
                                                          inline. Thank
                                                          you!
 
On
                                                          4 Feb 2025, at
                                                          18:18, Jared
                                                          Anderson via
                                                          config-dev
                                                          <confi...@xxxxxxxxxxx>
                                                          JA wrote:
 
JA>
                                                          This email is
                                                          a follow up to
                                                          the discussion
                                                          at the
                                                          2025-02-04
JA>
                                                          Jakarta EE
                                                          platform call.
 
JA>
                                                          In that call,
                                                          we discussed
                                                          an approach
                                                          where Jakarta
                                                          EE 12 could
JA>
                                                          effectively
                                                          use
                                                          MicroProfile
                                                          Config "as is"
                                                          with some
                                                          important
JA>
                                                          non-technical
accommodations.
 
JA>
                                                          1. The APIs
                                                          for Jakarta
                                                          Config would
                                                          be the
                                                          MicroProfile
                                                          Config APIs,
JA>
                                                          but with
                                                          jakarta
                                                          namespace.
                                                          Yes, a
                                                          copy/paste.
 
RC>
                                                          After the
                                                          initial
                                                          copy/paste,
                                                          how would
                                                          things
                                                          evolve? 
 
My
                                                          intention is
                                                          that technical
                                                          evolution
                                                          would take
                                                          place in the
MicroProfile
                                                          Config
                                                          project. In
                                                          the event of
                                                          Jakarta
                                                          specific
accommodations,
                                                          we would
 
1.
                                                          Cross that
                                                          bridge when we
                                                          come to it.
2.
                                                          Try to come up
                                                          with solutions
                                                          that are
                                                          palatable to
                                                          both
                                                          communities,
                                                          Jakarta 
 
                                                           EE and
                                                          MicroProfile.
3.
                                                          If absolutely
                                                          necessary, we
                                                          would define
                                                          content in MP
                                                          Config that
 
                                                           would have
                                                          the proviso
                                                          such as "this
                                                          only takes
                                                          effect in
                                                          Jakarta
 
                                                           EE
                                                          environments".
                                                          There is ample
                                                          precedent for
                                                          such
                                                          approaches.
                                                          See
 
                                                           what we did
                                                          with Faces
                                                          when
                                                          Validation was
                                                          present (in
                                                          EE) vs. not
 
                                                           present (such
                                                          as in Tomcat).
 
RC>
                                                          Would Jakarta
                                                          keep the APIs
                                                          in-sync?
 
Yes.
                                                          Every time
                                                          Jakarta needed
                                                          a new version,
                                                          they would
                                                          pick up a
chosen
                                                          release of MP
                                                          config to give
                                                          the copy/paste
                                                          treatment to.
 
RC>
                                                          What restricts
                                                          Jakarta from
                                                          using the API
                                                          as-is?
 
As
                                                          far as I
                                                          know: 
 
1.
                                                          A technical
                                                          problem
                                                          regarding
                                                          introducing
                                                          circular
                                                          dependencies.
2.
                                                          A
                                                          non-technical
                                                          problem where
                                                          Jakarta specs
                                                          may not make
 
                                                           dependencies
                                                          on
                                                          MicroProfile
                                                          artifacts.
 
JA>
                                                          2. The
                                                          implementation
                                                          may delegate
                                                          to the
                                                          MicroProfile
                                                          Config
                                                          implementation.
 
JA>
                                                          3. The Spec
                                                          document would
                                                          be one-line:
                                                          see the
                                                          corresponding
JA>
                                                          MicroProfile
                                                          config spec
                                                          document.  May
                                                          need
                                                          additional
                                                          text to
JA>
                                                          talk about the
                                                          difference in
                                                          namespace and
                                                          adding in
JA>
jakarta-config.properties until a new MP Config version added that
JA>
                                                          to its
                                                          specification. 
                                                          See #5 below.
 
JA>
                                                          4. The TCK
                                                          would be a
                                                          copy/paste of
                                                          the
                                                          MicroProfile
                                                          Config TCK
JA>
                                                          and updating
                                                          the name space
                                                          and adding
                                                          jakarta-config.properties
JA>
                                                          testing
 
JA>
                                                          5. Need to
                                                          introduce a
                                                          new line in
                                                          the
                                                          ConfigSource
                                                          (MicroProfile
JA>
                                                          Config API)
                                                          “Some
                                                          configuration
                                                          sources are
                                                          known as
                                                          default
JA>
                                                          configuration
                                                          sources. These
                                                          configuration
                                                          sources are
                                                          normally
JA>
                                                          available in
                                                          all
                                                          automatically-created
configurations, and can be
JA>
                                                          manually added
                                                          to
                                                          manually-created
                                                          configurations
                                                          as well. The
JA>
                                                          default
                                                          configuration
                                                          sources are:
 
JA>
                                                          1. System
                                                          properties,
                                                          with an
                                                          ordinal value
                                                          of 400
 
JA>
                                                          2. Environment
                                                          properties,
                                                          with an
                                                          ordinal value
                                                          of 300
 
JA>
                                                          3. The
                                                          /META-INF/jakarta-config.properties
                                                          resource, with
                                                          an ordinal
                                                          value of 200
 
JA>
                                                          4. The
                                                          /META-INF/microprofile-config.properties
                                                          resource, with
                                                          an
JA>
                                                          ordinal value
                                                          of 100
 
RC>
                                                          How about
                                                          dropping
                                                          microprofile-config.properties
                                                          (keep it for
RC>
                                                          compatibility)
                                                          and
                                                          jakarta-config.properties,
                                                          and use
RC>
application.properties? This one is already used by many popular
RC>
                                                          runtimes like
                                                          Spring,
                                                          Quarkus, and
                                                          Micronaut, to
                                                          name a few.
 
Roberto,
                                                          that's a rad
                                                          idea. I like
                                                          it.
                                                          Ed