SlideShare una empresa de Scribd logo
1 de 18
Descargar para leer sin conexión
SUPPORTING INCREMENTAL
CHANGES IN LARGE MODELS
   Jannik Laval, Simon Denier, Stéphane Ducasse
                 RMod Team - INRIA

                  Andy Kellens
          Software Languages Lab - VUB
ROADMAP
• Problem

• Different   naive approaches

  • copy

  • delta

  • lookup

• Our   proposal
PROBLEM

• How     to predict impact of changes ?

• How  to predict and compare different
 futures ?

• In   large models.
EXAMPLE
• move   mB1() in classA.

• remove   classC.

          Pack1             Pack1'


                   classA             classA'
                  mA1()              mA1'()
                  mA2()              mA2'()
                                     mB1'()
                   classB
                  mB1()               classB'
                  mB2()              mB2'()


                   classC
DIFFERENT NAIVE
            APPROACHES

• Copy

• Delta

• LookUp
COPY
Model 1

                                   Pack1

                               parentPackage
                                                                classC

       classA
                                                      classB
   parentClass
                                                        parentClass



     mA1()            mA2()    mB1()              mB2()

              to   from                 to     from

          anInvocation                 anInvocation




Model 2

                                  Pack1'

                               parentPackage


      classA'
                                                      classB'
   parentClass
                                                        parentClass



     mA1'()           mA2'()   mB1'()            mB2'()

              to   from                 to     from

          anInvocation'              anInvocation'
COPY
• Pros

 • each   version is complete

 • easy   to use and to transform

• Cons

 • high   creation time

 • high   memory usage
DELTA
Model 1

                                 Pack1

                             parentPackage
                                                             classC

       classA                                                         Model 2
                                                    classB
   parentClass                                                        - removeLinkBetween: classB and: mB1()
                                                     parentClass      - createLinkBetween: classA and: mB1()
                                                                      - removeClass: classC


     mA1()           mA2()   mB1()              mB2()

             to   from            to         from

          anInvocation               anInvocation
DELTA

• Pros

 • each    version is represented by its changes

 • fast   to create a version

• Cons

 • slow    to access a version
Model 1
                  LOOKUP
                                 Pack1

                             parentPackage
                                                             classC

       classA
                                                    classB
   parentClass
                                                     parentClass



     mA1()           mA2()   mB1()              mB2()

             to   from            to         from

          anInvocation               anInvocation




Model 2                        LookUp


                                Pack1'

                                                        removedClass
                                                             C

       classA'
                                                    classB'
   parentClass




                              mB1'()
LOOKUP

• Pros

 • only   changed entities are copied

• Cons

 • time   for lookUp

 • what   about removed elements ?
LOOKUP   Model 1

                                                            Pack1

                                                        parentPackage
                                                                                        classC

                                  classA
                                                                               classB
                              parentClass
                                                                                parentClass



                                mA1()           mA2()   mB1()              mB2()

                                        to   from            to         from


•a   problem:                        anInvocation               anInvocation




                           Model 2                        LookUp

 • mB2()   parentClass ?                                   Pack1'

                                                                                   removedClass
                                                                                        C

                                  classA'
                                                                               classB'
                              parentClass




                                                         mB1'()
PERFORMANCES
            cost of   cost of   memory
Approach
           creation   access     cost
  copy     ++++         1       ++++
  delta       +       ++++        +
 lookUp       +       ++++        +
ORION APPROACH              Model 1

                                                                  Pack1

                                                              parentPackage
                                                                                               classC

                                        classA
                                                                                     classB
                                    parentClass
                                                                                       parentClass




• pointers   approach                 mA1()           mA2()   mB1()

                                                                   to
                                                                                 mB2()

                                              to   from                       from

                                           anInvocation               anInvocation


• access   to updated elements
                                 Model 2

                                                                 Pack1'

  • by   an ID
                                       classA'


  • mB2()    parentClass ?
                                                                                     classB'




                                                              mB1()'
ORION APPROACH
• Pros

 • fastcreation and low memory usage: only
   changed elements

 • fast   access: with the ID or pointers

• Cons

 •a   model depends on its predecessors
PERFORMANCES

Approach    cost of   cost of   memory
           creation   access     cost
  copy      ++++        1       ++++
  delta       +       ++++        +
 lookUp       +       ++++        +
 Orion        +         +         +
ITS FUTURE

• Useit to make manual and automatic
 prediction changes

• Comparing    different changes

• Coupling   with analysis tools (Famix)
THANKS

SUPPORTING INCREMENTAL CHANGES IN
          LARGE MODELS

    Jannik Laval, Simon Denier, Stéphane Ducasse
                  RMod Team - INRIA

                   Andy Kellens
           Software Languages Lab - VUB

Más contenido relacionado

Más de ESUG

Migration process from monolithic to micro frontend architecture in mobile ap...
Migration process from monolithic to micro frontend architecture in mobile ap...Migration process from monolithic to micro frontend architecture in mobile ap...
Migration process from monolithic to micro frontend architecture in mobile ap...
ESUG
 
Analyzing Dart Language with Pharo: Report and early results
Analyzing Dart Language with Pharo: Report and early resultsAnalyzing Dart Language with Pharo: Report and early results
Analyzing Dart Language with Pharo: Report and early results
ESUG
 
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
ESUG
 
A Unit Test Metamodel for Test Generation
A Unit Test Metamodel for Test GenerationA Unit Test Metamodel for Test Generation
A Unit Test Metamodel for Test Generation
ESUG
 
Creating Unit Tests Using Genetic Programming
Creating Unit Tests Using Genetic ProgrammingCreating Unit Tests Using Genetic Programming
Creating Unit Tests Using Genetic Programming
ESUG
 
Threaded-Execution and CPS Provide Smooth Switching Between Execution Modes
Threaded-Execution and CPS Provide Smooth Switching Between Execution ModesThreaded-Execution and CPS Provide Smooth Switching Between Execution Modes
Threaded-Execution and CPS Provide Smooth Switching Between Execution Modes
ESUG
 
Exploring GitHub Actions through EGAD: An Experience Report
Exploring GitHub Actions through EGAD: An Experience ReportExploring GitHub Actions through EGAD: An Experience Report
Exploring GitHub Actions through EGAD: An Experience Report
ESUG
 
Pharo: a reflective language A first systematic analysis of reflective APIs
Pharo: a reflective language A first systematic analysis of reflective APIsPharo: a reflective language A first systematic analysis of reflective APIs
Pharo: a reflective language A first systematic analysis of reflective APIs
ESUG
 
Improving Performance Through Object Lifetime Profiling: the DataFrame Case
Improving Performance Through Object Lifetime Profiling: the DataFrame CaseImproving Performance Through Object Lifetime Profiling: the DataFrame Case
Improving Performance Through Object Lifetime Profiling: the DataFrame Case
ESUG
 
Pharo DataFrame: Past, Present, and Future
Pharo DataFrame: Past, Present, and FuturePharo DataFrame: Past, Present, and Future
Pharo DataFrame: Past, Present, and Future
ESUG
 
A New Architecture Reconciling Refactorings and Transformations
A New Architecture Reconciling Refactorings and TransformationsA New Architecture Reconciling Refactorings and Transformations
A New Architecture Reconciling Refactorings and Transformations
ESUG
 
gt4atproto, A Programmable Environment for Social Media
gt4atproto, A Programmable Environment for Social Mediagt4atproto, A Programmable Environment for Social Media
gt4atproto, A Programmable Environment for Social Media
ESUG
 

Más de ESUG (20)

Sequence: Pipeline modelling in Pharo
Sequence: Pipeline modelling in PharoSequence: Pipeline modelling in Pharo
Sequence: Pipeline modelling in Pharo
 
Migration process from monolithic to micro frontend architecture in mobile ap...
Migration process from monolithic to micro frontend architecture in mobile ap...Migration process from monolithic to micro frontend architecture in mobile ap...
Migration process from monolithic to micro frontend architecture in mobile ap...
 
Analyzing Dart Language with Pharo: Report and early results
Analyzing Dart Language with Pharo: Report and early resultsAnalyzing Dart Language with Pharo: Report and early results
Analyzing Dart Language with Pharo: Report and early results
 
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
 
A Unit Test Metamodel for Test Generation
A Unit Test Metamodel for Test GenerationA Unit Test Metamodel for Test Generation
A Unit Test Metamodel for Test Generation
 
Creating Unit Tests Using Genetic Programming
Creating Unit Tests Using Genetic ProgrammingCreating Unit Tests Using Genetic Programming
Creating Unit Tests Using Genetic Programming
 
Threaded-Execution and CPS Provide Smooth Switching Between Execution Modes
Threaded-Execution and CPS Provide Smooth Switching Between Execution ModesThreaded-Execution and CPS Provide Smooth Switching Between Execution Modes
Threaded-Execution and CPS Provide Smooth Switching Between Execution Modes
 
Exploring GitHub Actions through EGAD: An Experience Report
Exploring GitHub Actions through EGAD: An Experience ReportExploring GitHub Actions through EGAD: An Experience Report
Exploring GitHub Actions through EGAD: An Experience Report
 
Pharo: a reflective language A first systematic analysis of reflective APIs
Pharo: a reflective language A first systematic analysis of reflective APIsPharo: a reflective language A first systematic analysis of reflective APIs
Pharo: a reflective language A first systematic analysis of reflective APIs
 
Garbage Collector Tuning
Garbage Collector TuningGarbage Collector Tuning
Garbage Collector Tuning
 
Improving Performance Through Object Lifetime Profiling: the DataFrame Case
Improving Performance Through Object Lifetime Profiling: the DataFrame CaseImproving Performance Through Object Lifetime Profiling: the DataFrame Case
Improving Performance Through Object Lifetime Profiling: the DataFrame Case
 
Pharo DataFrame: Past, Present, and Future
Pharo DataFrame: Past, Present, and FuturePharo DataFrame: Past, Present, and Future
Pharo DataFrame: Past, Present, and Future
 
thisContext in the Debugger
thisContext in the DebuggerthisContext in the Debugger
thisContext in the Debugger
 
Websockets for Fencing Score
Websockets for Fencing ScoreWebsockets for Fencing Score
Websockets for Fencing Score
 
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScript
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScriptShowUs: PharoJS.org Develop in Pharo, Run on JavaScript
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScript
 
Advanced Object- Oriented Design Mooc
Advanced Object- Oriented Design MoocAdvanced Object- Oriented Design Mooc
Advanced Object- Oriented Design Mooc
 
A New Architecture Reconciling Refactorings and Transformations
A New Architecture Reconciling Refactorings and TransformationsA New Architecture Reconciling Refactorings and Transformations
A New Architecture Reconciling Refactorings and Transformations
 
BioSmalltalk
BioSmalltalkBioSmalltalk
BioSmalltalk
 
gt4atproto, A Programmable Environment for Social Media
gt4atproto, A Programmable Environment for Social Mediagt4atproto, A Programmable Environment for Social Media
gt4atproto, A Programmable Environment for Social Media
 
Roassal3 update
Roassal3 updateRoassal3 update
Roassal3 update
 

Último

+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
?#DUbAI#??##{{(☎️+971_581248768%)**%*]'#abortion pills for sale in dubai@
 
Why Teams call analytics are critical to your entire business
Why Teams call analytics are critical to your entire businessWhy Teams call analytics are critical to your entire business
Why Teams call analytics are critical to your entire business
panagenda
 

Último (20)

+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
+971581248768>> SAFE AND ORIGINAL ABORTION PILLS FOR SALE IN DUBAI AND ABUDHA...
 
Why Teams call analytics are critical to your entire business
Why Teams call analytics are critical to your entire businessWhy Teams call analytics are critical to your entire business
Why Teams call analytics are critical to your entire business
 
MS Copilot expands with MS Graph connectors
MS Copilot expands with MS Graph connectorsMS Copilot expands with MS Graph connectors
MS Copilot expands with MS Graph connectors
 
FWD Group - Insurer Innovation Award 2024
FWD Group - Insurer Innovation Award 2024FWD Group - Insurer Innovation Award 2024
FWD Group - Insurer Innovation Award 2024
 
Boost Fertility New Invention Ups Success Rates.pdf
Boost Fertility New Invention Ups Success Rates.pdfBoost Fertility New Invention Ups Success Rates.pdf
Boost Fertility New Invention Ups Success Rates.pdf
 
DEV meet-up UiPath Document Understanding May 7 2024 Amsterdam
DEV meet-up UiPath Document Understanding May 7 2024 AmsterdamDEV meet-up UiPath Document Understanding May 7 2024 Amsterdam
DEV meet-up UiPath Document Understanding May 7 2024 Amsterdam
 
[BuildWithAI] Introduction to Gemini.pdf
[BuildWithAI] Introduction to Gemini.pdf[BuildWithAI] Introduction to Gemini.pdf
[BuildWithAI] Introduction to Gemini.pdf
 
Strategize a Smooth Tenant-to-tenant Migration and Copilot Takeoff
Strategize a Smooth Tenant-to-tenant Migration and Copilot TakeoffStrategize a Smooth Tenant-to-tenant Migration and Copilot Takeoff
Strategize a Smooth Tenant-to-tenant Migration and Copilot Takeoff
 
Corporate and higher education May webinar.pptx
Corporate and higher education May webinar.pptxCorporate and higher education May webinar.pptx
Corporate and higher education May webinar.pptx
 
"I see eyes in my soup": How Delivery Hero implemented the safety system for ...
"I see eyes in my soup": How Delivery Hero implemented the safety system for ..."I see eyes in my soup": How Delivery Hero implemented the safety system for ...
"I see eyes in my soup": How Delivery Hero implemented the safety system for ...
 
MINDCTI Revenue Release Quarter One 2024
MINDCTI Revenue Release Quarter One 2024MINDCTI Revenue Release Quarter One 2024
MINDCTI Revenue Release Quarter One 2024
 
Understanding the FAA Part 107 License ..
Understanding the FAA Part 107 License ..Understanding the FAA Part 107 License ..
Understanding the FAA Part 107 License ..
 
Introduction to Multilingual Retrieval Augmented Generation (RAG)
Introduction to Multilingual Retrieval Augmented Generation (RAG)Introduction to Multilingual Retrieval Augmented Generation (RAG)
Introduction to Multilingual Retrieval Augmented Generation (RAG)
 
Apidays New York 2024 - Scaling API-first by Ian Reasor and Radu Cotescu, Adobe
Apidays New York 2024 - Scaling API-first by Ian Reasor and Radu Cotescu, AdobeApidays New York 2024 - Scaling API-first by Ian Reasor and Radu Cotescu, Adobe
Apidays New York 2024 - Scaling API-first by Ian Reasor and Radu Cotescu, Adobe
 
Apidays New York 2024 - APIs in 2030: The Risk of Technological Sleepwalk by ...
Apidays New York 2024 - APIs in 2030: The Risk of Technological Sleepwalk by ...Apidays New York 2024 - APIs in 2030: The Risk of Technological Sleepwalk by ...
Apidays New York 2024 - APIs in 2030: The Risk of Technological Sleepwalk by ...
 
Platformless Horizons for Digital Adaptability
Platformless Horizons for Digital AdaptabilityPlatformless Horizons for Digital Adaptability
Platformless Horizons for Digital Adaptability
 
Apidays New York 2024 - The value of a flexible API Management solution for O...
Apidays New York 2024 - The value of a flexible API Management solution for O...Apidays New York 2024 - The value of a flexible API Management solution for O...
Apidays New York 2024 - The value of a flexible API Management solution for O...
 
DBX First Quarter 2024 Investor Presentation
DBX First Quarter 2024 Investor PresentationDBX First Quarter 2024 Investor Presentation
DBX First Quarter 2024 Investor Presentation
 
Artificial Intelligence Chap.5 : Uncertainty
Artificial Intelligence Chap.5 : UncertaintyArtificial Intelligence Chap.5 : Uncertainty
Artificial Intelligence Chap.5 : Uncertainty
 
Exploring Multimodal Embeddings with Milvus
Exploring Multimodal Embeddings with MilvusExploring Multimodal Embeddings with Milvus
Exploring Multimodal Embeddings with Milvus
 

Supporting Incremental Changes in Large Models

  • 1. SUPPORTING INCREMENTAL CHANGES IN LARGE MODELS Jannik Laval, Simon Denier, Stéphane Ducasse RMod Team - INRIA Andy Kellens Software Languages Lab - VUB
  • 2. ROADMAP • Problem • Different naive approaches • copy • delta • lookup • Our proposal
  • 3. PROBLEM • How to predict impact of changes ? • How to predict and compare different futures ? • In large models.
  • 4. EXAMPLE • move mB1() in classA. • remove classC. Pack1 Pack1' classA classA' mA1() mA1'() mA2() mA2'() mB1'() classB mB1() classB' mB2() mB2'() classC
  • 5. DIFFERENT NAIVE APPROACHES • Copy • Delta • LookUp
  • 6. COPY Model 1 Pack1 parentPackage classC classA classB parentClass parentClass mA1() mA2() mB1() mB2() to from to from anInvocation anInvocation Model 2 Pack1' parentPackage classA' classB' parentClass parentClass mA1'() mA2'() mB1'() mB2'() to from to from anInvocation' anInvocation'
  • 7. COPY • Pros • each version is complete • easy to use and to transform • Cons • high creation time • high memory usage
  • 8. DELTA Model 1 Pack1 parentPackage classC classA Model 2 classB parentClass - removeLinkBetween: classB and: mB1() parentClass - createLinkBetween: classA and: mB1() - removeClass: classC mA1() mA2() mB1() mB2() to from to from anInvocation anInvocation
  • 9. DELTA • Pros • each version is represented by its changes • fast to create a version • Cons • slow to access a version
  • 10. Model 1 LOOKUP Pack1 parentPackage classC classA classB parentClass parentClass mA1() mA2() mB1() mB2() to from to from anInvocation anInvocation Model 2 LookUp Pack1' removedClass C classA' classB' parentClass mB1'()
  • 11. LOOKUP • Pros • only changed entities are copied • Cons • time for lookUp • what about removed elements ?
  • 12. LOOKUP Model 1 Pack1 parentPackage classC classA classB parentClass parentClass mA1() mA2() mB1() mB2() to from to from •a problem: anInvocation anInvocation Model 2 LookUp • mB2() parentClass ? Pack1' removedClass C classA' classB' parentClass mB1'()
  • 13. PERFORMANCES cost of cost of memory Approach creation access cost copy ++++ 1 ++++ delta + ++++ + lookUp + ++++ +
  • 14. ORION APPROACH Model 1 Pack1 parentPackage classC classA classB parentClass parentClass • pointers approach mA1() mA2() mB1() to mB2() to from from anInvocation anInvocation • access to updated elements Model 2 Pack1' • by an ID classA' • mB2() parentClass ? classB' mB1()'
  • 15. ORION APPROACH • Pros • fastcreation and low memory usage: only changed elements • fast access: with the ID or pointers • Cons •a model depends on its predecessors
  • 16. PERFORMANCES Approach cost of cost of memory creation access cost copy ++++ 1 ++++ delta + ++++ + lookUp + ++++ + Orion + + +
  • 17. ITS FUTURE • Useit to make manual and automatic prediction changes • Comparing different changes • Coupling with analysis tools (Famix)
  • 18. THANKS SUPPORTING INCREMENTAL CHANGES IN LARGE MODELS Jannik Laval, Simon Denier, Stéphane Ducasse RMod Team - INRIA Andy Kellens Software Languages Lab - VUB