Title: Spur, a new object representation for Cog
Speaker: Elliot Miranda
Wed, August 20, 9am – 10am
Video:
Part 1: https://www.youtube.com/watch?v=k0nBNS1aHZ4
Part 2: https://www.youtube.com/watch?v=sn3irBZE7g4
Part 3: https://www.youtube.com/watch?v=1Vg0iFeg_pA
Abstract: Spur is a new object representation and memory manager for the Cog VM. The object representation includes immediate characters and its simplicity allows Cog's JIT to implement many more operations, resulting in a faster VM. The object representation is designed to share the object header and the majority of the memory management code between 32-bit and 64-bit versions. Spur has two features new to Squeak/Pharo, the ability to grow and shrink memory via segments, and the ability to pin objects in memory. Spur has one altogether novel feature, a partial read barrier, which takes advantage of Smalltalk's message sending to provide lazy forwarding, which allows the system to implement become efficiently while retaining the speed advantages of direct pointers. This talk will explain these features with minimal manifestation of machine code on the slides and, for this author, plenty of pleasing pictures.
Bio: Eliot Miranda is a long-time Smalltalk systems programmer and virtual machine architect. He started his technical life developing holographic optics for bubble chamber physics, in so doing discovering a love of computing. His early work, started while a student at York University, produced the BrouHaHa series of virtual machines. These were Smalltalk-80 interpreters and threaded code JITs, written in C. While at Queen Mary College in the University of London he was involved in applying these implementations to prototyping what-you-see-is-what-i-see interfaces for IBM and to implementing the bulk of the software for the Active Book, a very early ARM-based tablet computer. He was virtual machine lead and then technical lead for VisualWorks for a decade at ParcPlace and its successors, before joining Cadence where he helped adapt Squeak to implement Newspeak. He then joined Qwaq, the company applying Croquet to business communications, where he implemented Cog. He is now back at Cadence in a team applying Cog and Newspeak to SoC design support. He is currently enjoying collaborating with a number of people on Cog-related projects, not least of which is an adaptive optimization system for Pharo/Squeak called Sista.
2)
Title: Sista: Improving Cog’s JIT performance
Speaker: Clément Béra
Thu, August 21, 9:45am – 10:30am
Video Part1
https://www.youtube.com/watch?v=X4E_FoLysJg
Video Part2
https://www.youtube.com/watch?v=gZOk3qojoVE
Description
Abstract: Although recent improvements of the Cog VM performance made it one of the fastest available Smalltalk virtual machine, the overhead compared to optimized C code remains important. Efficient industrial object oriented virtual machine, such as Javascript V8's engine for Google Chrome and Oracle Java Hotspot can reach on many benchs the performance of optimized C code thanks to adaptive optimizations performed their JIT compilers. The VM becomes then cleverer, and after executing numerous times the same portion of codes, it stops the code execution, looks at what it is doing and recompiles critical portion of codes in code faster to run based on the current environment and previous executions.
Bio: Clément Béra and Eliot Miranda has been working together on Cog's JIT performance for the last year. Clément Béra is a young engineer and has been working in the Pharo team for the past two years. Eliot Miranda is a Smalltalk VM expert who, among others, has implemented Cog's JIT and the Spur Memory Manager for Cog.
This document provides an overview and introduction to Cuis Smalltalk, a complete but compact Smalltalk development environment. It describes Cuis as a pure object-oriented language derived from Squeak, with an elegant, simple, and clean design. The document outlines some of Cuis' key differences from other Smalltalk implementations like its active approach to system complexity, high code quality, and compact size. It also discusses Cuis' audience, package management system, available packages, and active developer community.
Este documento trata sobre la metaprogramación en PHP. Explica brevemente la historia de la metaprogramación a través del lenguaje LISP y las ideas de Alan Kay. Luego define la metaprogramación y reflexión, describiendo la introspección y la intercesión. Proporciona algunos ejemplos básicos de metaprogramación en PHP como reglas de programación, visitor y proxy perezoso, y menciona características adicionales que le faltan a PHP como thisContext y addMethod/removeMethod. Finalmente, comparte recursos para aprender más sobre estos tem
The document discusses the challenges of implementing Smalltalk on the Java Virtual Machine (JVM) and how Redline Smalltalk addresses these challenges. It uses ANTLR to parse Smalltalk source code and ASM to generate Java bytecode. Redline Smalltalk compiles Smalltalk code into Java classes that subclass ProtoObject and implement primitives as static methods. When a Smalltalk class is executed, its bytecode is loaded and instantiated via the SmalltalkClassLoader, resulting in message sends that encode the original Smalltalk logic.
This document summarizes a presentation about a web terminal application. It discusses the client/server architecture with the client running in a browser using JavaScript and communicating with the server via a delta protocol. On the server side, it uses Smalltalk applications and domain models to manage the user interface and synchronization with the client. It provides an example of a chat application user interface design to demonstrate how the page specification works.
Pragmas: Literal Messages as Powerful Method AnnotationsESUG
This document discusses the use of pragmas in Smalltalk as a way to annotate methods and provide additional metadata. It provides several examples of pragmas being used to mark methods for specific purposes like marking unwind methods, specifying menu items, and defining class-side configuration methods. The document suggests pragmas could potentially be used in more general ways for things like COM servers or defining preferences.
Title: Sista: Improving Cog’s JIT performance
Speaker: Clément Béra
Thu, August 21, 9:45am – 10:30am
Video Part1
https://www.youtube.com/watch?v=X4E_FoLysJg
Video Part2
https://www.youtube.com/watch?v=gZOk3qojoVE
Description
Abstract: Although recent improvements of the Cog VM performance made it one of the fastest available Smalltalk virtual machine, the overhead compared to optimized C code remains important. Efficient industrial object oriented virtual machine, such as Javascript V8's engine for Google Chrome and Oracle Java Hotspot can reach on many benchs the performance of optimized C code thanks to adaptive optimizations performed their JIT compilers. The VM becomes then cleverer, and after executing numerous times the same portion of codes, it stops the code execution, looks at what it is doing and recompiles critical portion of codes in code faster to run based on the current environment and previous executions.
Bio: Clément Béra and Eliot Miranda has been working together on Cog's JIT performance for the last year. Clément Béra is a young engineer and has been working in the Pharo team for the past two years. Eliot Miranda is a Smalltalk VM expert who, among others, has implemented Cog's JIT and the Spur Memory Manager for Cog.
This document provides an overview and introduction to Cuis Smalltalk, a complete but compact Smalltalk development environment. It describes Cuis as a pure object-oriented language derived from Squeak, with an elegant, simple, and clean design. The document outlines some of Cuis' key differences from other Smalltalk implementations like its active approach to system complexity, high code quality, and compact size. It also discusses Cuis' audience, package management system, available packages, and active developer community.
Este documento trata sobre la metaprogramación en PHP. Explica brevemente la historia de la metaprogramación a través del lenguaje LISP y las ideas de Alan Kay. Luego define la metaprogramación y reflexión, describiendo la introspección y la intercesión. Proporciona algunos ejemplos básicos de metaprogramación en PHP como reglas de programación, visitor y proxy perezoso, y menciona características adicionales que le faltan a PHP como thisContext y addMethod/removeMethod. Finalmente, comparte recursos para aprender más sobre estos tem
The document discusses the challenges of implementing Smalltalk on the Java Virtual Machine (JVM) and how Redline Smalltalk addresses these challenges. It uses ANTLR to parse Smalltalk source code and ASM to generate Java bytecode. Redline Smalltalk compiles Smalltalk code into Java classes that subclass ProtoObject and implement primitives as static methods. When a Smalltalk class is executed, its bytecode is loaded and instantiated via the SmalltalkClassLoader, resulting in message sends that encode the original Smalltalk logic.
This document summarizes a presentation about a web terminal application. It discusses the client/server architecture with the client running in a browser using JavaScript and communicating with the server via a delta protocol. On the server side, it uses Smalltalk applications and domain models to manage the user interface and synchronization with the client. It provides an example of a chat application user interface design to demonstrate how the page specification works.
Pragmas: Literal Messages as Powerful Method AnnotationsESUG
This document discusses the use of pragmas in Smalltalk as a way to annotate methods and provide additional metadata. It provides several examples of pragmas being used to mark methods for specific purposes like marking unwind methods, specifying menu items, and defining class-side configuration methods. The document suggests pragmas could potentially be used in more general ways for things like COM servers or defining preferences.
Workshop: Identifying concept inventories in agile programmingESUG
This document discusses the development of a concept inventory to identify common misconceptions in agile programming and object-oriented development. The project aims to strengthen collaboration between INRIA/Lille and ÉTS/UQAM by creating a concept inventory that can be used to improve teaching of agile development with object-oriented languages like TypeScript, JavaScript, and Pharo. The methodology involves identifying misconceptions, proposing a concept inventory, and validating it in courses by measuring understanding before and after instruction. A workshop will help identify initial misconceptions in Smalltalk/Pharo by capturing them in a collaborative tool.
This document proposes integrating documentation into the Pharo language metamodel and environment to improve documentation support. It suggests making documentation first-class citizens in Pharo by providing built-in support and a minimal API, which would allow tight integration with development tools and future extensions without requiring grammar changes or large efforts. This could improve documentation quality by enabling direct references between code and documentation and automatic logging of documentation usage.
The Pharo Debugger and Debugging tools: Advances and RoadmapESUG
This document outlines advances and the roadmap for debugging tools in Pharo. It discusses recent improvements to the debugging infrastructure, including architectural changes and new debugging commands. It also describes upcoming work, such as additional infrastructure improvements, an emergency debugger, support for meta-object protocols, a redesigned user experience, a remote debugger, and improved documentation. The document concludes by inviting participants to help evaluate new debugging experiments.
The document describes Sequence, a pipeline modeling and discrete event simulation framework developed in Pharo Smalltalk. Sequence allows describing system resources, building blocks that use those resources, assembling scenarios from blocks, collecting information during simulated runs, and interactively exploring system traces. The framework implements a discrete event simulation engine with event streams that model periodic processes and resources. Sequence provides tools for evaluating system performance through simulation before complete hardware is available.
Migration process from monolithic to micro frontend architecture in mobile ap...ESUG
This document discusses migrating a monolithic mobile application called CARL Touch to a micro frontend architecture. It presents a migration process involving three steps: 1) analysis of the monolithic codebase, 2) identification of potential micro frontends, and 3) transformation of the codebase to implement the identified micro frontends. Previous experiments at Berger-Levrault involving two teams migrating CARL Touch provided insights. The proposed process uses static and dynamic analysis, code visualization and clustering techniques to help identify optimal micro frontends and transform the codebase in a semi-automated manner.
Analyzing Dart Language with Pharo: Report and early resultsESUG
This document summarizes an analysis of the Dart programming language using tools in the Pharo environment. It describes generating a parser for Dart using SmaCC, which produces an AST. It also details defining a Famix meta-model for Dart and the Chartreuse-D importer that creates a FamixDart model from the AST. Future work is outlined, including improving SmaCCDart, continuing to develop the FamixDart meta-model, and handling dynamic types when importing associations. The goal is to analyze Dart and explore modeling Flutter applications.
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6ESUG
This document summarizes research on transpiling Pharo classes to JavaScript using ECMAScript 5 versus ECMAScript 6. It finds that transpiling to ES6 provides benefits like significantly faster load times, improved benchmark performance up to 43%, and more idiomatic code compared to ES5. However, fully emulating Smalltalk semantics like metaclass inheritance remains challenging when targeting JavaScript.
The document presents an approach for automated test generation from software models and execution traces. Key aspects of the approach include using metamodels to represent the codebase, values, and desired unit test structure. Models are built from the codebase and traces, then transformations are applied to generate unit tests conforming to the test metamodel. Abstract syntax trees are used to export the generated tests to code. The approach aims to generate tests that are relevant, readable and maintainable without relying on existing tests. An example demonstrates generating a JUnit test from an application class.
Genetic programming is used to generate unit tests by evolving test code via genetic algorithms to maximize coverage. Tests are represented as chromosomes of object and message statements. The genetic algorithm selects tests based on coverage, combines tests through crossover, and replaces tests in the population over generations to find optimal test sequences. Future work includes improving path exploration and comparing with other test generation tools.
Threaded-Execution and CPS Provide Smooth Switching Between Execution ModesESUG
Threaded execution and continuation-passing style (CPS) allow for smooth switching between execution modes in Zag Smalltalk. Threaded execution interprets code as a sequence of addresses like bytecode but is 2.3-4.7 times faster, while CPS passes continuations explicitly like in functional languages and is 3-5 times faster than bytecode. Both approaches allow fallback to debugging. The implementation shares context and stack between modes to easily switch with proper object structures.
Exploring GitHub Actions through EGAD: An Experience ReportESUG
This document summarizes an experience report on exploring GitHub Actions through EGAD, a tool for GitHub Action analysis. It discusses three key lessons learned: 1) Composing a story by documenting tasks and linking documentation to code, 2) Navigating custom views to conduct research, and 3) Supporting onboarding of researchers by assigning mentors, scheduling meetings, and encouraging use of resources. EGAD takes workflow YAML files, wraps them in a domain model to provide context, and allows inspecting examples to fully explore the GitHub Actions domain model.
Pharo: a reflective language A first systematic analysis of reflective APIsESUG
This document analyzes the reflective features and APIs in Pharo, a reflective programming language. It presents a catalog of Pharo's reflective APIs and analyzes how they relate to metaobjects. The analysis highlights areas for potential improvement, such as providing solutions for intercession on state reads/writes and addressing constraints when changing an object's class. The document contributes to understanding Pharo's reflective design and its evolution over time.
The document discusses garbage collector tuning for applications with pathological allocation patterns. It begins by explaining the motivation and issues caused by pathological patterns, such as applications taking over an hour and a half to run. It then provides an overview of garbage collection and how allocation patterns can impact performance. The document dives into two specific tuning techniques - increasing the full GC threshold to prevent premature full GCs from being triggered, and increasing the tenuring threshold to avoid large objects residing in the remembered set and slowing down scavenges. These tunings resulted in significant performance improvements for the sample DataFrame application, reducing the run time from over an hour and a half to around seven minutes.
Improving Performance Through Object Lifetime Profiling: the DataFrame CaseESUG
This document discusses improving garbage collection performance in Pharo through object lifetime profiling. It presents Illimani, a lifetime profiler developed for Pharo. Illimani was used to profile the lifetimes of objects created when loading a large DataFrame. The profiling revealed that most objects had short lifetimes, suggesting the garbage collector could be tuned. Tuning the garbage collector parameters based on the lifetime profiles improved the performance of loading the DataFrame.
This document discusses the past, present, and future of Pharo DataFrames. It began as a student project but has evolved into a mature project with dedicated engineers, improving performance and adding functionality. Future plans include further performance enhancements, adding more functionality, better integration with other Pharo projects, and support for big data. Evaluation of DataFrames is also planned.
This document discusses issues with thisContext in the Pharo debugger not correctly representing the execution context and being the DoIt context instead. This was fixed in Pharo12 by making thisContext a variable object that is wrapped in a DoItVariable, so the debugger context is used. When inspecting or doing DoIt, the doIt Variable is pushed and read to provide the proper execution context.
This document proposes using websockets to display fencing scores and a chronometer from an arena server to mobile phones over the internet in real-time. It includes links to video examples of a chronometer display and photos from fencing competitions.
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScriptESUG
This document discusses PharoJS, which allows developers to develop applications in Pharo and then export them to run as JavaScript applications. PharoJS enables 100% of Pharo code to be executed during development, and then 100% of that same code is exported to JavaScript to be executed in production. The document also briefly mentions deployment options for exported PharoJS applications like GitHub Pages and GitHub Actions.
The document contains testimonials from participants of the Pharo MOOC praising its effectiveness at teaching object-oriented design. It also announces an upcoming advanced design MOOC that will have over 60 lectures, slides, videos and an exercise booklet. Finally, it provides links to the course websites and encourages people to stay tuned for the new MOOC.
A New Architecture Reconciling Refactorings and TransformationsESUG
This document discusses reconciling refactorings and transformations in software engineering. It proposes a new architecture where refactorings decorate transformations by checking preconditions and composing multiple transformations. Refactorings ensure transformations are applied safely while transformations focus on model changes. Open questions remain around precondition handling and composition semantics. The goals are to reduce duplication, support custom refactorings/transformations, and provide a modern driver-based user interface.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Workshop: Identifying concept inventories in agile programmingESUG
This document discusses the development of a concept inventory to identify common misconceptions in agile programming and object-oriented development. The project aims to strengthen collaboration between INRIA/Lille and ÉTS/UQAM by creating a concept inventory that can be used to improve teaching of agile development with object-oriented languages like TypeScript, JavaScript, and Pharo. The methodology involves identifying misconceptions, proposing a concept inventory, and validating it in courses by measuring understanding before and after instruction. A workshop will help identify initial misconceptions in Smalltalk/Pharo by capturing them in a collaborative tool.
This document proposes integrating documentation into the Pharo language metamodel and environment to improve documentation support. It suggests making documentation first-class citizens in Pharo by providing built-in support and a minimal API, which would allow tight integration with development tools and future extensions without requiring grammar changes or large efforts. This could improve documentation quality by enabling direct references between code and documentation and automatic logging of documentation usage.
The Pharo Debugger and Debugging tools: Advances and RoadmapESUG
This document outlines advances and the roadmap for debugging tools in Pharo. It discusses recent improvements to the debugging infrastructure, including architectural changes and new debugging commands. It also describes upcoming work, such as additional infrastructure improvements, an emergency debugger, support for meta-object protocols, a redesigned user experience, a remote debugger, and improved documentation. The document concludes by inviting participants to help evaluate new debugging experiments.
The document describes Sequence, a pipeline modeling and discrete event simulation framework developed in Pharo Smalltalk. Sequence allows describing system resources, building blocks that use those resources, assembling scenarios from blocks, collecting information during simulated runs, and interactively exploring system traces. The framework implements a discrete event simulation engine with event streams that model periodic processes and resources. Sequence provides tools for evaluating system performance through simulation before complete hardware is available.
Migration process from monolithic to micro frontend architecture in mobile ap...ESUG
This document discusses migrating a monolithic mobile application called CARL Touch to a micro frontend architecture. It presents a migration process involving three steps: 1) analysis of the monolithic codebase, 2) identification of potential micro frontends, and 3) transformation of the codebase to implement the identified micro frontends. Previous experiments at Berger-Levrault involving two teams migrating CARL Touch provided insights. The proposed process uses static and dynamic analysis, code visualization and clustering techniques to help identify optimal micro frontends and transform the codebase in a semi-automated manner.
Analyzing Dart Language with Pharo: Report and early resultsESUG
This document summarizes an analysis of the Dart programming language using tools in the Pharo environment. It describes generating a parser for Dart using SmaCC, which produces an AST. It also details defining a Famix meta-model for Dart and the Chartreuse-D importer that creates a FamixDart model from the AST. Future work is outlined, including improving SmaCCDart, continuing to develop the FamixDart meta-model, and handling dynamic types when importing associations. The goal is to analyze Dart and explore modeling Flutter applications.
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6ESUG
This document summarizes research on transpiling Pharo classes to JavaScript using ECMAScript 5 versus ECMAScript 6. It finds that transpiling to ES6 provides benefits like significantly faster load times, improved benchmark performance up to 43%, and more idiomatic code compared to ES5. However, fully emulating Smalltalk semantics like metaclass inheritance remains challenging when targeting JavaScript.
The document presents an approach for automated test generation from software models and execution traces. Key aspects of the approach include using metamodels to represent the codebase, values, and desired unit test structure. Models are built from the codebase and traces, then transformations are applied to generate unit tests conforming to the test metamodel. Abstract syntax trees are used to export the generated tests to code. The approach aims to generate tests that are relevant, readable and maintainable without relying on existing tests. An example demonstrates generating a JUnit test from an application class.
Genetic programming is used to generate unit tests by evolving test code via genetic algorithms to maximize coverage. Tests are represented as chromosomes of object and message statements. The genetic algorithm selects tests based on coverage, combines tests through crossover, and replaces tests in the population over generations to find optimal test sequences. Future work includes improving path exploration and comparing with other test generation tools.
Threaded-Execution and CPS Provide Smooth Switching Between Execution ModesESUG
Threaded execution and continuation-passing style (CPS) allow for smooth switching between execution modes in Zag Smalltalk. Threaded execution interprets code as a sequence of addresses like bytecode but is 2.3-4.7 times faster, while CPS passes continuations explicitly like in functional languages and is 3-5 times faster than bytecode. Both approaches allow fallback to debugging. The implementation shares context and stack between modes to easily switch with proper object structures.
Exploring GitHub Actions through EGAD: An Experience ReportESUG
This document summarizes an experience report on exploring GitHub Actions through EGAD, a tool for GitHub Action analysis. It discusses three key lessons learned: 1) Composing a story by documenting tasks and linking documentation to code, 2) Navigating custom views to conduct research, and 3) Supporting onboarding of researchers by assigning mentors, scheduling meetings, and encouraging use of resources. EGAD takes workflow YAML files, wraps them in a domain model to provide context, and allows inspecting examples to fully explore the GitHub Actions domain model.
Pharo: a reflective language A first systematic analysis of reflective APIsESUG
This document analyzes the reflective features and APIs in Pharo, a reflective programming language. It presents a catalog of Pharo's reflective APIs and analyzes how they relate to metaobjects. The analysis highlights areas for potential improvement, such as providing solutions for intercession on state reads/writes and addressing constraints when changing an object's class. The document contributes to understanding Pharo's reflective design and its evolution over time.
The document discusses garbage collector tuning for applications with pathological allocation patterns. It begins by explaining the motivation and issues caused by pathological patterns, such as applications taking over an hour and a half to run. It then provides an overview of garbage collection and how allocation patterns can impact performance. The document dives into two specific tuning techniques - increasing the full GC threshold to prevent premature full GCs from being triggered, and increasing the tenuring threshold to avoid large objects residing in the remembered set and slowing down scavenges. These tunings resulted in significant performance improvements for the sample DataFrame application, reducing the run time from over an hour and a half to around seven minutes.
Improving Performance Through Object Lifetime Profiling: the DataFrame CaseESUG
This document discusses improving garbage collection performance in Pharo through object lifetime profiling. It presents Illimani, a lifetime profiler developed for Pharo. Illimani was used to profile the lifetimes of objects created when loading a large DataFrame. The profiling revealed that most objects had short lifetimes, suggesting the garbage collector could be tuned. Tuning the garbage collector parameters based on the lifetime profiles improved the performance of loading the DataFrame.
This document discusses the past, present, and future of Pharo DataFrames. It began as a student project but has evolved into a mature project with dedicated engineers, improving performance and adding functionality. Future plans include further performance enhancements, adding more functionality, better integration with other Pharo projects, and support for big data. Evaluation of DataFrames is also planned.
This document discusses issues with thisContext in the Pharo debugger not correctly representing the execution context and being the DoIt context instead. This was fixed in Pharo12 by making thisContext a variable object that is wrapped in a DoItVariable, so the debugger context is used. When inspecting or doing DoIt, the doIt Variable is pushed and read to provide the proper execution context.
This document proposes using websockets to display fencing scores and a chronometer from an arena server to mobile phones over the internet in real-time. It includes links to video examples of a chronometer display and photos from fencing competitions.
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScriptESUG
This document discusses PharoJS, which allows developers to develop applications in Pharo and then export them to run as JavaScript applications. PharoJS enables 100% of Pharo code to be executed during development, and then 100% of that same code is exported to JavaScript to be executed in production. The document also briefly mentions deployment options for exported PharoJS applications like GitHub Pages and GitHub Actions.
The document contains testimonials from participants of the Pharo MOOC praising its effectiveness at teaching object-oriented design. It also announces an upcoming advanced design MOOC that will have over 60 lectures, slides, videos and an exercise booklet. Finally, it provides links to the course websites and encourages people to stay tuned for the new MOOC.
A New Architecture Reconciling Refactorings and TransformationsESUG
This document discusses reconciling refactorings and transformations in software engineering. It proposes a new architecture where refactorings decorate transformations by checking preconditions and composing multiple transformations. Refactorings ensure transformations are applied safely while transformations focus on model changes. Open questions remain around precondition handling and composition semantics. The goals are to reduce duplication, support custom refactorings/transformations, and provide a modern driver-based user interface.
E-commerce Development Services- Hornet DynamicsHornet Dynamics
For any business hoping to succeed in the digital age, having a strong online presence is crucial. We offer Ecommerce Development Services that are customized according to your business requirements and client preferences, enabling you to create a dynamic, safe, and user-friendly online store.
Using Query Store in Azure PostgreSQL to Understand Query PerformanceGrant Fritchey
Microsoft has added an excellent new extension in PostgreSQL on their Azure Platform. This session, presented at Posette 2024, covers what Query Store is and the types of information you can get out of it.
Microservice Teams - How the cloud changes the way we workSven Peters
A lot of technical challenges and complexity come with building a cloud-native and distributed architecture. The way we develop backend software has fundamentally changed in the last ten years. Managing a microservices architecture demands a lot of us to ensure observability and operational resiliency. But did you also change the way you run your development teams?
Sven will talk about Atlassian’s journey from a monolith to a multi-tenanted architecture and how it affected the way the engineering teams work. You will learn how we shifted to service ownership, moved to more autonomous teams (and its challenges), and established platform and enablement teams.
Flutter is a popular open source, cross-platform framework developed by Google. In this webinar we'll explore Flutter and its architecture, delve into the Flutter Embedder and Flutter’s Dart language, discover how to leverage Flutter for embedded device development, learn about Automotive Grade Linux (AGL) and its consortium and understand the rationale behind AGL's choice of Flutter for next-gen IVI systems. Don’t miss this opportunity to discover whether Flutter is right for your project.
What to do when you have a perfect model for your software but you are constrained by an imperfect business model?
This talk explores the challenges of bringing modelling rigour to the business and strategy levels, and talking to your non-technical counterparts in the process.
Top Benefits of Using Salesforce Healthcare CRM for Patient Management.pdfVALiNTRY360
Salesforce Healthcare CRM, implemented by VALiNTRY360, revolutionizes patient management by enhancing patient engagement, streamlining administrative processes, and improving care coordination. Its advanced analytics, robust security, and seamless integration with telehealth services ensure that healthcare providers can deliver personalized, efficient, and secure patient care. By automating routine tasks and providing actionable insights, Salesforce Healthcare CRM enables healthcare providers to focus on delivering high-quality care, leading to better patient outcomes and higher satisfaction. VALiNTRY360's expertise ensures a tailored solution that meets the unique needs of any healthcare practice, from small clinics to large hospital systems.
For more info visit us https://valintry360.com/solutions/health-life-sciences
Unveiling the Advantages of Agile Software Development.pdfbrainerhub1
Learn about Agile Software Development's advantages. Simplify your workflow to spur quicker innovation. Jump right in! We have also discussed the advantages.
UI5con 2024 - Keynote: Latest News about UI5 and it’s EcosystemPeter Muessig
Learn about the latest innovations in and around OpenUI5/SAPUI5: UI5 Tooling, UI5 linter, UI5 Web Components, Web Components Integration, UI5 2.x, UI5 GenAI.
Recording:
https://www.youtube.com/live/MSdGLG2zLy8?si=INxBHTqkwHhxV5Ta&t=0
7. oops
BS Direct Pointers
size...flags...hash
class
inst vars
...
refcount
HPS Object Table Indirection
size...flags...hash
class
indirection
inst vars
...
D-machine OTE
20-bit address
size
class
inst vars
...
Wednesday, 20 August 2014
8. oops! yeah, right...
size...flags...hash
class
indirection
inst vars
...
size...flags...inst size...hash...class index
indirection
inst vars
...
64-bit HPS 7
sparse
class
table
Wednesday, 20 August 2014
9. class indices/class tags
class index is index of class in class table
class’s identity hash is its index in class table
∴ its instances’ class tag
Behavior>>identityHash (& Behavior>>new)
use them in method caches; resolve to class
object on #class or full method lookup
constants, never moved by GC
cheap allocation of well-known objects
puns & special non-objects
#slots identityHash fmt class index
Wednesday, 20 August 2014
10. evolution
top-down selection pressure
(≈tests)
bottom-up refinement
(≈≈ pink plane)
exaptation
(≈ blue plane)
Wednesday, 20 August 2014
12. The VM System
heap
lcoaockhuep prims irnetteerrp gc &
alloc
Wednesday, 20 August 2014
13. The VM System
heap
lcoaockhuep zcoodnee sztoancek
prims irnetteerrp jit gc &
alloc
Wednesday, 20 August 2014
14. method lookup
findNewMethod
! "Find the compiled method to be run when the current
messageSelector is sent to the class lkupClass, setting
the values of newMethod and primitiveIndex."
! <inline: true>
! | ok |
! ok := self lookupInMethodCacheSel: messageSelector class: lkupClass.
! ok ifFalse: "entry was not found in the cache; look it up the hard way"
! ! [self lookupMethodInClass: lkupClass.
! ! self addNewMethodToCache]
Wednesday, 20 August 2014
15. Exapt
method cache probe
class tags
stack zone
primitives
Wednesday, 20 August 2014
16. Exaptation
become lazy
all objects can be forwarders
forwarded class tag fails method cache probe
follow on message lookup
stack zone scan avoids inst var access read barrier
Wednesday, 20 August 2014
17. become
size flags hash class index
inst var 0 inst var 1
.....
size flags hash class index
inst var 0 inst var 1
.....
Wednesday, 20 August 2014
18. become
size flags forwarded index
forwarding ptr
copy copy
size flags hash class index
inst var 0 inst var 1
.....
size flags forwarded index
forwarding ptr
size flags hash class index
inst var 0 inst var 1
.....
Wednesday, 20 August 2014
20. lazy forwarding issues
inst var access
(& method access in interpreter)
message sends
class hierarchy method lookup
global var access (including super sends)
primitives
Wednesday, 20 August 2014
21. lazy forwarding: inst vars
partial read barrier
size flags forwarded index
forwarding ptr
copy copy
size flags hash class index
inst var 0 inst var 1
.....
size flags forwarded index
forwarding ptr
size flags hash class index
inst var 0 inst var 1
.....
+ if became pointer or method object,
scan stack zone to follow forwarding pointers
Wednesday, 20 August 2014
23. lazy forwarding:
class hierarchy method lookup
after any pointer become could scan
every class in class table
every method on entry to stack zone
KISS
read barrier on access
superclassOf: classObj
! "Read barrier here costs very little because lookup is rare,
& class and superclass almost certainly share a cache line."
^objectMemory followField: SuperclassIndex ofObject: classObj
Wednesday, 20 August 2014
24. lazy forwarding:
global variable access
after any pointer or method become could scan
every method in stack & code zones
every method on entry to stack zone
KISS
read barrier on access
pushLiteralVariable: literalIndex
! | litVar |
! litVar := self literal: literalIndex.
! (heap isForwarded: litVar) ifTrue:
! ! [litVar := heap followForwarded: litVar].
! self push: (heap fetchPointer: ValueIndex ofObject: litVar)
Wednesday, 20 August 2014
25. lazy forwarding: primitives
bits
width
height
depth
offset
mask
x
y
bits
width
height
depth
offset
self validate
ifTrue: [self operate]
ifFalse: [self fail]
x
y
Wednesday, 20 August 2014
28. ephemerons
processEphemerons
! "There are ephemerons to be scavenged. Scavenge them and fire any whose keys are
! still in pastSpace and/or eden. The unscavenged ephemerons in this cycle can only be
! fired if all the unscavenged ephemerons in this cycle are firable, because references
! to ephemeron keys from unfired ephemerons should prevent the ephemerons with
! those keys from firing. So scavenge ephemerons with surviving keys, and only if none
! are found, fire ephemerons with unreferenced keys, and scavenge them. Read the
! class comment for a more in-depth description of the algorithm."
! | unfiredEphemeronsScavenged |
! unfiredEphemeronsScavenged := self scavengeUnfiredEphemeronsInRememberedSet.
! self scavengeUnfiredEphemeronsOnEphemeronList ifTrue:
! ! [unfiredEphemeronsScavenged := true].
! unfiredEphemeronsScavenged ifFalse:
! ! [self fireEphemeronsInRememberedSet.
! ! self fireEphemeronsOnEphemeronList]
Wednesday, 20 August 2014
29. object size/heap walk
8 22 5 22
<= 254 identityHash fmt class index
at least one slot
255 slot count
255 identityHash fmt class index
Wednesday, 20 August 2014