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.
                            
                              
                            
                            
                            
                              
                            
                            
                              RC> A few comments inline. Thank you!
                            
                              
                            
                            
                            
                              
                            
                            
                              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