First class Variables in Pharo
•
0 likes•619 views
E
ESUGFirst class Variables in Pharo First Name: Marcus Last Name: Denker Type: Talk Video 1: https://www.youtube.com/watch?v=hEWKV9eWAGY Video 2: https://www.youtube.com/watch?v=fWo1V_C0cu8 Abstract: In this talk I will present the first class variables in Pharo: With Slots, Class, and Global variables, we now model variables as objects. These mete-objects provide a new reflective API for variables and in addition, and allow the programmer to introduce new kinds of variables. This talk will present the ideas behind and show how to use first class variables by presenting examples. It will present how variable meta objects simplify reflecting on variables in combination with Reflectivity. Bio: Marcus Denker is a permanent researcher at INRIA Lille - Nord Europe. Before, he was a postdoc at the PLEIAD lab/DCC University of Chile and the Software Composition Group, University of Bern. His research focuses on reflection and meta-programming for dynamic languages. He is an active participant in the Squeak and Pharo open source communities for many years and the co-founder of 2Denker/Cologne/Germany. Marcus received a PhD in Computer Science from the University of Bern/Switzerland in 2008 and a Dipl.-Inform. (MSc) from the University of Karlsruhe/Germany in 2004.
Report
Share
Report
Share
Download to read offline
Recommended
Reflection in Pharo: Beyond Smalltak
Talk: “Reflection in Pharo: Beyond Smalltak”, Talk held at SOFT research group VUB, Brussels, Belgium, January 25, 2016.
Thinkful - Intro to JavaScript
This document provides an introduction to JavaScript, covering key concepts like variables, data types, functions, and how the web works. It begins with introductions from the instructor and mentor. It then discusses programming fundamentals like defining problems, finding solutions, and implementing them in code. The document explains that JavaScript is used for both front-end and back-end development. It covers JavaScript variables, strings, numbers, Booleans, and basic functions. It provides examples and challenges for readers to practice the concepts. In the end, it discusses continuing education options through 1-on-1 mentorship.
Dynamically Composing Collection Operations through Collection Promises
Dynamically Composing Collection Operations through Collection Promises.
Juan Pablo Sandoval Alcocer, Marcus Denker,
Alexandre Bergel, Yasett Acuran
Presented at IWST 2016
Getting started with typescript and angular 2
The Typescript is getting popular day by day, mainly because of its use in angular 2 and its type annotation in these slides i give a brief introduction to typescript and how it works with angular2
Advanced Reflection in Pharo
This document discusses advanced reflection capabilities in Pharo. It describes how instance variables are currently represented as strings but could be modeled as objects using layouts and slots. It also explains how method structures are not currently modeled at a fine-grained level and proposes using abstract syntax trees (ASTs) to represent methods as objects with sub-elements like message sends, assignments, and variable access. This would enable capabilities like behavioral reflection through meta-object links on AST nodes. The document advocates "ASTs everywhere" and sub-method reflection with meta-links in future versions of Pharo.
Intro to javascript (6:19)
This document provides an introduction to JavaScript. It discusses the basics of how the web works with clients and servers, gives a brief history of JavaScript, and covers key JavaScript concepts like variables, data types, functions, and parameters. The format for the session is outlined, which includes reviewing these concepts, practicing with challenges, and discussing next steps for continuing to learn.
Intro to JavaScript - Thinkful LA, June 2017
This document provides an introduction to JavaScript for beginners. It covers basic JavaScript concepts like variables, data types, functions, and objects. It also explains how the web works at a high level with clients making requests to servers. The document is meant to give attendees an overview of key JavaScript concepts to practice during a workshop on getting started with JavaScript.
AngularConf2015
This document discusses the advantages of using TypeScript for developing Angular applications. It begins with an introduction to TypeScript, including how it adds types and classes to JavaScript to improve code structure and tooling. The presenter then demonstrates how to write an Angular todo list application using TypeScript, comparing the syntax for services, controllers, and directives between regular JavaScript and TypeScript implementations. Decorators are also introduced as how Angular 2.0 will annotate classes and properties. Overall, TypeScript is shown to add significant benefits for organizing code and developing Angular applications.
Recommended
Reflection in Pharo: Beyond Smalltak
Talk: “Reflection in Pharo: Beyond Smalltak”, Talk held at SOFT research group VUB, Brussels, Belgium, January 25, 2016.
Thinkful - Intro to JavaScript
This document provides an introduction to JavaScript, covering key concepts like variables, data types, functions, and how the web works. It begins with introductions from the instructor and mentor. It then discusses programming fundamentals like defining problems, finding solutions, and implementing them in code. The document explains that JavaScript is used for both front-end and back-end development. It covers JavaScript variables, strings, numbers, Booleans, and basic functions. It provides examples and challenges for readers to practice the concepts. In the end, it discusses continuing education options through 1-on-1 mentorship.
Dynamically Composing Collection Operations through Collection Promises
Dynamically Composing Collection Operations through Collection Promises.
Juan Pablo Sandoval Alcocer, Marcus Denker,
Alexandre Bergel, Yasett Acuran
Presented at IWST 2016
Getting started with typescript and angular 2
The Typescript is getting popular day by day, mainly because of its use in angular 2 and its type annotation in these slides i give a brief introduction to typescript and how it works with angular2
Advanced Reflection in Pharo
This document discusses advanced reflection capabilities in Pharo. It describes how instance variables are currently represented as strings but could be modeled as objects using layouts and slots. It also explains how method structures are not currently modeled at a fine-grained level and proposes using abstract syntax trees (ASTs) to represent methods as objects with sub-elements like message sends, assignments, and variable access. This would enable capabilities like behavioral reflection through meta-object links on AST nodes. The document advocates "ASTs everywhere" and sub-method reflection with meta-links in future versions of Pharo.
Intro to javascript (6:19)
This document provides an introduction to JavaScript. It discusses the basics of how the web works with clients and servers, gives a brief history of JavaScript, and covers key JavaScript concepts like variables, data types, functions, and parameters. The format for the session is outlined, which includes reviewing these concepts, practicing with challenges, and discussing next steps for continuing to learn.
Intro to JavaScript - Thinkful LA, June 2017
This document provides an introduction to JavaScript for beginners. It covers basic JavaScript concepts like variables, data types, functions, and objects. It also explains how the web works at a high level with clients making requests to servers. The document is meant to give attendees an overview of key JavaScript concepts to practice during a workshop on getting started with JavaScript.
AngularConf2015
This document discusses the advantages of using TypeScript for developing Angular applications. It begins with an introduction to TypeScript, including how it adds types and classes to JavaScript to improve code structure and tooling. The presenter then demonstrates how to write an Angular todo list application using TypeScript, comparing the syntax for services, controllers, and directives between regular JavaScript and TypeScript implementations. Decorators are also introduced as how Angular 2.0 will annotate classes and properties. Overall, TypeScript is shown to add significant benefits for organizing code and developing Angular applications.
Conscious Decoupling - Lone Star PHP
By using a comprehensive feature-filled framework we can build software fast. On the other hand, by decoupling our applications we can build sofware that is independent of our framework and infrastructure choices, and therefore longer lasting.
We can't do both, is one approach always right?
In this talk we'll look at different decoupling techniques, what problems they solve, and when they make sense. We will learn some concrete techniques to discover where we should be investing in decoupling, and when we should let the framework maintainers do the work for us.
JavaScript operators
JavaScript operators allow manipulation of values and perform computations on operands. There are various types of operators including arithmetic, assignment, comparison, logical, and ternary operators. Arithmetic operators perform math operations like addition, subtraction, multiplication, and division on operands.
JavaScript Basics
This document provides an overview and plan for learning JavaScript. It covers introductory topics like variables, operators, functions, loops, and events. It also explains why JavaScript is important for web development as one of the three main languages, along with HTML and CSS. The document outlines how to integrate JavaScript into HTML pages and defines common JavaScript concepts.
Type script - advanced usage and practices
This document provides an overview of advanced TypeScript concepts and best practices. It discusses the TypeScript toolchain and environment, ES2015+ features like let, modules, and unit testing. It covers the TypeScript type system including type inference, annotations, and strict checking. Other topics include decorators, structural typing, destructuring, and the differences between TypeScript and JavaScript.
Shapeless- Generic programming for Scala
"Introduction to Shapeless- Generic programming for Scala !". Broadly speaking, shapeless is about programming with types. Doing things at compile-time that would more commonly be done at runtime to ensure type-safety. A long list of features provided by Shapeless are explained in the enclosed presentation.
Web development basics (Part-7)
The document discusses various JavaScript concepts including ECMAScript, the difference between ES5 and ES6, web crawlers, DOM manipulation, OOPs in JavaScript, data structures like Set and Map, symbols, JavaScript engines, and recursion. ECMAScript is the standardized language specification while JavaScript is the programming language. Key differences between ES5 and ES6 include new features added in ES6 like modules and default parameters. Web crawlers systematically browse pages on the web to index content. JavaScript allows OOPs concepts like abstraction, encapsulation, inheritance and more through its prototype-based approach. Common JavaScript engines include V8, SpiderMonkey and Chakra.
Web development basics (Part-5)
We will cover whole of the web development basics comprising of HTML, CSS, JavaScript in this series.
Following are topics useful for any newbie to intermediate who is interested in learning Web Development
TypeScript Modules
TypeScript is an amazing substitute for JavaScript that solves a bunch of significant problems that are surprisingly common in large JavaScript code bases. But, by solving those problems, it also creates a new one: it's now easier than ever to create larger and more complex code bases. It turns out that accommodating that complexity while supporting all the different JavaScript environments is quite a challenge.
Which is why TypeScript has multiple module systems, unfortunately with confusing names and poor guidance. In this session, we sort out the mess and talk about the differences between internal and external modules, writing client and server code, how the TypeScript modules map to JavaScript modules in different versions of JavaScript, and about integration with build tools like Gulp.
These are the slides for the talk I gave at the JavaScript Israel Meetup: http://www.meetup.com/JavaScript-Israel/events/228923402/
TypeScript
This document provides an overview of TypeScript, including:
- What TypeScript is and how it supports features like interfaces, classes, and subclasses
- How TypeScript uses a compiler to provide type checking and transpiles code to JavaScript
- Examples of using basic TypeScript syntax like types, functions, classes, and interfaces
- How to set up a TypeScript development environment and use the tsc compiler
- Popular IDEs and resources for learning more about TypeScript
Swift Micro-services and AWS Technologies
Swift offers a compelling opportunity to build reliable, scalable and lightweight micro-services. This talk will discuss how I am investigating the use of Swift micro-services - running in ECS and potentially Lambda, fronted by API gateway - with AWS technologies such as managing data models with DynamoDb.
Web development basics (Part-4)
We will cover whole of the web development basics comprising of HTML, CSS, JavaScript in this series.
Following are topics useful for any newbie to intermediate who is interested in learning Web Development
Introducing type script
TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. It allows for large scale JavaScript application development with features like classes, inheritance, modules, generators, async/await, and decorators. TypeScript introduces strong typing, interfaces, generics, and other design-time features not available in JavaScript to reduce complexity in large codebases. It supports the future of JavaScript by allowing the use of ES6 and ES7 features today through compiler options. Getting started is easy using the TypeScript playground or boilerplate projects on GitHub.
Model with actors and implement with Akka
This document provides an overview of actor modeling and how to implement actors using the Akka library. It begins with explaining the actor model and benefits of actors over threads. It then discusses how to create actors with Akka, demonstrating with a multiplayer chess game. The schedule outlines explaining the actor model for 1/4 of the time and how to create Akka actors for 3/4 of the time using the chess game demo. Useful links are provided for Akka documentation and chess/game related projects.
TypeScript: coding JavaScript without the pain
This document discusses TypeScript, a superset of JavaScript that adds optional static typing and class-based object-oriented programming. It allows developers to gradually introduce typing into JavaScript code for improved productivity and catch errors early. The document covers TypeScript features like interfaces, classes, modules, type definitions, and comparisons to alternatives like CoffeeScript and Dart. It concludes that TypeScript allows gradual adoption of typing while following the future ECMAScript standard.
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 02)
This lecture covers the very basics of the syntax of the Swift programming language. The course is an intensive and very compressed deep dive into iOS development in Swift. Visit the course web page to get copies of the course outline, lecture notes, sample code, etc. Course website: http://www.themobilemontage.com/2015/05/12/ios-bootcamp-learning-to-create-awesome-apps-on-ios-using-swift/
YouTube Link to lecture: https://youtu.be/fwstpDs2biQ
Intro to javascript (4 week)
This document is an introduction to JavaScript presented by Jamal O'Garro of Code Crew. It covers the basics of JavaScript including data types, operators, variables, functions, objects, and the DOM. It also discusses more advanced topics like object-oriented JavaScript, prototypal inheritance, AJAX, APIs, frameworks, and Node.js. The goal is to provide an overview of the core concepts and capabilities of the JavaScript programming language.
Reflection in Pharo5
This document summarizes a talk about reflection and abstract syntax trees (AST) in Pharo5. It discusses how the AST is now more integrated and accessible via methods like #ast. Annotations called MetaLinks can be added to AST nodes to modify behavior. A reflective compiler called Basis uses AST annotations and metaobjects to implement features like live recompilation without restarting the image. Questions from the audience are then invited.
Swift, a quick overview
This document provides an overview of Swift, including some key features such as no header files, type inference, computed properties, property observers, generics, extensions, closures, optionals, and interoperability with Objective-C. It notes that Swift aims to be a safe language with features like array typing, optional values to mark nil, and requirements to handle all cases in switches. The document concludes by stating Swift code can be accessed from Objective-C with the @objc prefix and that Swift classes can inherit from Objective-C classes.
Java script ppt
DOJO session from the IT team at The Health and Social Care Information Centre - All you need to know about Java Script!
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 03)
This lecture covers the very basics of the syntax of the Swift programming language.
The course is an intensive and very compressed deep dive into iOS development in Swift. Visit the course web page to get copies of the course outline, lecture notes, sample code, etc.
Course website: http://www.themobilemontage.com/2015/05/12/ios-bootcamp-learning-to-create-awesome-apps-on-ios-using-swift/
YouTube Link to lecture: TBD
The Pharo Evolution
The Pharo Evolution
When
Tue, July 14, 4:15pm – 4:45pm
Description
First name: Esteban
Last name: Lorenzano
Type: talk
Video Part1: https://www.youtube.com/watch?v=yzss4mzwAAo
Video Part2: https://www.youtube.com/watch?v=HEGBNC-uOuo
Abstract: How will Pharo look in releases 5, 6 and even 7? This talk will show the kitchen of Pharo, what we are working on and what we are planning for the future (and how we plan to achieve them).
Bio: Esteban Lorenzano, 43 years old. He studied -and let unfinished- Computer Sciences at Universidad de Buenos Aires, and worked since 1994 in several object oriented technologies (Delphi, C++, Java), where he scaled from “Junior Programmer” to “Senior Architect”. On 2007 he and two friends began a new start-up, Smallworks, an enterprise for agile developments, centered on Smalltalk. Currently, he is working in the RMoD INRIA team in Lille, France, as core developer for Pharo.
Painting with Roassal2
Title: Painting with Roassal2
Speaker: Alexandre Bergel
Fri, August 22, 9:45am – 10:30am
Video Part1: https://www.youtube.com/watch?v=DiF0VyIwKb0
Video Part2: https://www.youtube.com/watch?v=EXwQQnXD0QE
Abstract: Roassal2 is an agile visualization engine. Thanks to some advanced scripting facilities, one can easily paint and interact with objects. Roassal2 offer a great range of features:
- based on Athens and Cairo for smooth and fast drawing,
- advanced bezier curves for drawing organic lines,
- exportable to plain HTML / Amber / VisualWorks,
- advanced support for curve and chart drawing,
- offer a framework for easily defining sophisticated visualizations, ...
Roassal2 is being used in a large range of domains, including code execution profiling, source code quality, geographical maps, visualization of stellar pictures.
The presentation will be demo-driven.
Bio:
Alexandre Bergel is Assistant Professor and researcher at the University of Chile. Alexandre Bergel and his collaborators carry out research in software engineering and software quality, more specifically on code profiling, testing and data visualization.
Alexandre Bergel has authored over 60 articles, published in international and peer reviewed scientific forums, including the most competitive conferences and journals in the field of software engineering. Alexandre has participated to over 50 program committees of international events. Alexandre has also a strong interest in applying his research results to industry. Several of his research prototypes have been turned into products and adopted by major companies in the semi-conductor industry and certification of critical software systems.
Alexandre co-authored the book http://www.deepIntoPharo.com
More Related Content
What's hot
Conscious Decoupling - Lone Star PHP
By using a comprehensive feature-filled framework we can build software fast. On the other hand, by decoupling our applications we can build sofware that is independent of our framework and infrastructure choices, and therefore longer lasting.
We can't do both, is one approach always right?
In this talk we'll look at different decoupling techniques, what problems they solve, and when they make sense. We will learn some concrete techniques to discover where we should be investing in decoupling, and when we should let the framework maintainers do the work for us.
JavaScript operators
JavaScript operators allow manipulation of values and perform computations on operands. There are various types of operators including arithmetic, assignment, comparison, logical, and ternary operators. Arithmetic operators perform math operations like addition, subtraction, multiplication, and division on operands.
JavaScript Basics
This document provides an overview and plan for learning JavaScript. It covers introductory topics like variables, operators, functions, loops, and events. It also explains why JavaScript is important for web development as one of the three main languages, along with HTML and CSS. The document outlines how to integrate JavaScript into HTML pages and defines common JavaScript concepts.
Type script - advanced usage and practices
This document provides an overview of advanced TypeScript concepts and best practices. It discusses the TypeScript toolchain and environment, ES2015+ features like let, modules, and unit testing. It covers the TypeScript type system including type inference, annotations, and strict checking. Other topics include decorators, structural typing, destructuring, and the differences between TypeScript and JavaScript.
Shapeless- Generic programming for Scala
"Introduction to Shapeless- Generic programming for Scala !". Broadly speaking, shapeless is about programming with types. Doing things at compile-time that would more commonly be done at runtime to ensure type-safety. A long list of features provided by Shapeless are explained in the enclosed presentation.
Web development basics (Part-7)
The document discusses various JavaScript concepts including ECMAScript, the difference between ES5 and ES6, web crawlers, DOM manipulation, OOPs in JavaScript, data structures like Set and Map, symbols, JavaScript engines, and recursion. ECMAScript is the standardized language specification while JavaScript is the programming language. Key differences between ES5 and ES6 include new features added in ES6 like modules and default parameters. Web crawlers systematically browse pages on the web to index content. JavaScript allows OOPs concepts like abstraction, encapsulation, inheritance and more through its prototype-based approach. Common JavaScript engines include V8, SpiderMonkey and Chakra.
Web development basics (Part-5)
We will cover whole of the web development basics comprising of HTML, CSS, JavaScript in this series.
Following are topics useful for any newbie to intermediate who is interested in learning Web Development
TypeScript Modules
TypeScript is an amazing substitute for JavaScript that solves a bunch of significant problems that are surprisingly common in large JavaScript code bases. But, by solving those problems, it also creates a new one: it's now easier than ever to create larger and more complex code bases. It turns out that accommodating that complexity while supporting all the different JavaScript environments is quite a challenge.
Which is why TypeScript has multiple module systems, unfortunately with confusing names and poor guidance. In this session, we sort out the mess and talk about the differences between internal and external modules, writing client and server code, how the TypeScript modules map to JavaScript modules in different versions of JavaScript, and about integration with build tools like Gulp.
These are the slides for the talk I gave at the JavaScript Israel Meetup: http://www.meetup.com/JavaScript-Israel/events/228923402/
TypeScript
This document provides an overview of TypeScript, including:
- What TypeScript is and how it supports features like interfaces, classes, and subclasses
- How TypeScript uses a compiler to provide type checking and transpiles code to JavaScript
- Examples of using basic TypeScript syntax like types, functions, classes, and interfaces
- How to set up a TypeScript development environment and use the tsc compiler
- Popular IDEs and resources for learning more about TypeScript
Swift Micro-services and AWS Technologies
Swift offers a compelling opportunity to build reliable, scalable and lightweight micro-services. This talk will discuss how I am investigating the use of Swift micro-services - running in ECS and potentially Lambda, fronted by API gateway - with AWS technologies such as managing data models with DynamoDb.
Web development basics (Part-4)
We will cover whole of the web development basics comprising of HTML, CSS, JavaScript in this series.
Following are topics useful for any newbie to intermediate who is interested in learning Web Development
Introducing type script
TypeScript is a typed superset of JavaScript that compiles to plain JavaScript. It allows for large scale JavaScript application development with features like classes, inheritance, modules, generators, async/await, and decorators. TypeScript introduces strong typing, interfaces, generics, and other design-time features not available in JavaScript to reduce complexity in large codebases. It supports the future of JavaScript by allowing the use of ES6 and ES7 features today through compiler options. Getting started is easy using the TypeScript playground or boilerplate projects on GitHub.
Model with actors and implement with Akka
This document provides an overview of actor modeling and how to implement actors using the Akka library. It begins with explaining the actor model and benefits of actors over threads. It then discusses how to create actors with Akka, demonstrating with a multiplayer chess game. The schedule outlines explaining the actor model for 1/4 of the time and how to create Akka actors for 3/4 of the time using the chess game demo. Useful links are provided for Akka documentation and chess/game related projects.
TypeScript: coding JavaScript without the pain
This document discusses TypeScript, a superset of JavaScript that adds optional static typing and class-based object-oriented programming. It allows developers to gradually introduce typing into JavaScript code for improved productivity and catch errors early. The document covers TypeScript features like interfaces, classes, modules, type definitions, and comparisons to alternatives like CoffeeScript and Dart. It concludes that TypeScript allows gradual adoption of typing while following the future ECMAScript standard.
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 02)
This lecture covers the very basics of the syntax of the Swift programming language. The course is an intensive and very compressed deep dive into iOS development in Swift. Visit the course web page to get copies of the course outline, lecture notes, sample code, etc. Course website: http://www.themobilemontage.com/2015/05/12/ios-bootcamp-learning-to-create-awesome-apps-on-ios-using-swift/
YouTube Link to lecture: https://youtu.be/fwstpDs2biQ
Intro to javascript (4 week)
This document is an introduction to JavaScript presented by Jamal O'Garro of Code Crew. It covers the basics of JavaScript including data types, operators, variables, functions, objects, and the DOM. It also discusses more advanced topics like object-oriented JavaScript, prototypal inheritance, AJAX, APIs, frameworks, and Node.js. The goal is to provide an overview of the core concepts and capabilities of the JavaScript programming language.
Reflection in Pharo5
This document summarizes a talk about reflection and abstract syntax trees (AST) in Pharo5. It discusses how the AST is now more integrated and accessible via methods like #ast. Annotations called MetaLinks can be added to AST nodes to modify behavior. A reflective compiler called Basis uses AST annotations and metaobjects to implement features like live recompilation without restarting the image. Questions from the audience are then invited.
Swift, a quick overview
This document provides an overview of Swift, including some key features such as no header files, type inference, computed properties, property observers, generics, extensions, closures, optionals, and interoperability with Objective-C. It notes that Swift aims to be a safe language with features like array typing, optional values to mark nil, and requirements to handle all cases in switches. The document concludes by stating Swift code can be accessed from Objective-C with the @objc prefix and that Swift classes can inherit from Objective-C classes.
Java script ppt
DOJO session from the IT team at The Health and Social Care Information Centre - All you need to know about Java Script!
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 03)
This lecture covers the very basics of the syntax of the Swift programming language.
The course is an intensive and very compressed deep dive into iOS development in Swift. Visit the course web page to get copies of the course outline, lecture notes, sample code, etc.
Course website: http://www.themobilemontage.com/2015/05/12/ios-bootcamp-learning-to-create-awesome-apps-on-ios-using-swift/
YouTube Link to lecture: TBD
What's hot (20)
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 02)
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 02)
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 03)
iOS Bootcamp: learning to create awesome apps on iOS using Swift (Lecture 03)
Viewers also liked
The Pharo Evolution
The Pharo Evolution
When
Tue, July 14, 4:15pm – 4:45pm
Description
First name: Esteban
Last name: Lorenzano
Type: talk
Video Part1: https://www.youtube.com/watch?v=yzss4mzwAAo
Video Part2: https://www.youtube.com/watch?v=HEGBNC-uOuo
Abstract: How will Pharo look in releases 5, 6 and even 7? This talk will show the kitchen of Pharo, what we are working on and what we are planning for the future (and how we plan to achieve them).
Bio: Esteban Lorenzano, 43 years old. He studied -and let unfinished- Computer Sciences at Universidad de Buenos Aires, and worked since 1994 in several object oriented technologies (Delphi, C++, Java), where he scaled from “Junior Programmer” to “Senior Architect”. On 2007 he and two friends began a new start-up, Smallworks, an enterprise for agile developments, centered on Smalltalk. Currently, he is working in the RMoD INRIA team in Lille, France, as core developer for Pharo.
Painting with Roassal2
Title: Painting with Roassal2
Speaker: Alexandre Bergel
Fri, August 22, 9:45am – 10:30am
Video Part1: https://www.youtube.com/watch?v=DiF0VyIwKb0
Video Part2: https://www.youtube.com/watch?v=EXwQQnXD0QE
Abstract: Roassal2 is an agile visualization engine. Thanks to some advanced scripting facilities, one can easily paint and interact with objects. Roassal2 offer a great range of features:
- based on Athens and Cairo for smooth and fast drawing,
- advanced bezier curves for drawing organic lines,
- exportable to plain HTML / Amber / VisualWorks,
- advanced support for curve and chart drawing,
- offer a framework for easily defining sophisticated visualizations, ...
Roassal2 is being used in a large range of domains, including code execution profiling, source code quality, geographical maps, visualization of stellar pictures.
The presentation will be demo-driven.
Bio:
Alexandre Bergel is Assistant Professor and researcher at the University of Chile. Alexandre Bergel and his collaborators carry out research in software engineering and software quality, more specifically on code profiling, testing and data visualization.
Alexandre Bergel has authored over 60 articles, published in international and peer reviewed scientific forums, including the most competitive conferences and journals in the field of software engineering. Alexandre has participated to over 50 program committees of international events. Alexandre has also a strong interest in applying his research results to industry. Several of his research prototypes have been turned into products and adopted by major companies in the semi-conductor industry and certification of critical software systems.
Alexandre co-authored the book http://www.deepIntoPharo.com
Concurrency in Smalltalk -- Beyond Threads
Martin is setting up a projector to display his laptop presentation. The document discusses concurrency models like threads and their disadvantages like race conditions and deadlocks. It introduces the E programming language which uses objects, composition, distribution and security to allow robust composition of concurrent components without these issues. E uses vats, immediate and eventual message sends, promises to represent asynchronous results, and exceptions to handle errors. While E addresses problems with threads, implementing its model fully would require syntax changes and better data object support.
Behavioral Reflection in Pharo
This document summarizes a talk about reflection and abstract syntax trees (AST) in Pharo5. It discusses how the AST is now more integrated and accessible via methods like #ast. Annotations called MetaLinks can be added to AST nodes to intercept and modify code at runtime. This enables features like on-the-fly recompilation using reflective methods. Demos are shown of creating twins, invalidating methods, and annotating nodes to tag executed statements for coverage analysis.
Towards Well Planned Code Cities
Towards Well Planned Code Cities
First Name: Natalia
Last Name: Tymchuk
Type: Talk
Abstract:
Software visualization has been shown as effective to support program and system comprehension. A possible solution adopts the city metaphor, and visualizes software systems as 3D cities. Most of the existing implementations, like CodeCity, exploit rectangle packing layout for placing the entities in a compact positioning. However, the distance between elements is determined by the layout algorithm only, without any connection to the actual structure of the system and the relations between software entities, which are fundamental for comprehension and maintenance.
We are currently investigating a new 3D representation for visualizing large software systems as cities. In our tool, we exploit force based layout to place software entities like classes and packages based on their relations, for example by considering client dependency. Our cities look more ``organic'', characterized by dependent entities grouped together, and less coupled entities more far away from each other.
Bio: I'm a Ph.D. student at the Faculty of Informatics of University of Lugano. I am working under the supervision of Prof. Dr. Michele Lanza, in the REVEAL research group. My main topic is how to improve the visualization of software systems in a useful and realistic way. On the last ESUG I presented Voronoi diagram builder, while 2 years ago I worked on the project “SciSmalltalk - Ordinary Differential Equations Solver” in GSoC.
Scratching the itch, making Scratch for the Raspberry Pie
Title: Scratching the itch, making Scratch for the Raspberry Pie
Speaker: Tim Rowledge
Fri, August 22, 12:00pm – 12:30pm
Abstract: Scratch was originally written in a Squeak 2.8 era image. Much has changed since then and to make the Raspberry Pi run Scratch as well as possible we have ported the code forward to a 4.5 image so it can run on a StackVM; and soon a Cog VM. A substantial amount of Smalltalk code has had to be rewritten to do this and yet we have to maintain complete compatibility with the original system to avoid overloading the teachers that use it in their classes. A new branch of Cog for the ARM cpu is being written as well.
Bio: Tim Rowledge has almost 30 years of Smalltalk experience, and almost as much with ARM. Somehow the two have always gone together.
Toward a Platform for Visual Debugging
The document proposes a platform for visual debugging that builds upon existing omniscient and object-centric debugging approaches. It describes an abstract visual stack debugger subclass and debugging session subclass that track side effects. The session's "step over" method executes and tracks changes. Research on questions programmers ask found 44 common questions around variables, data access/modification, types/objects, and relationships that a visual debugger could help address. It suggests looking for a VisualStackDebugger implementation on Smalltalkhub.
Smalltalk-driven GUI Testing
Smalltalk-driven GUI Testing
First Name: Andreas
Last Name: Hiltner
Type: Talk/Demonstration
Video1: https://www.youtube.com/watch?v=Adh9rgFX0fY
Video2: https://www.youtube.com/watch?v=ih1-iY4nJww
Abstract
In this session, Andreas Hiltner, Lead Software Engineer from Cincom Systems, Inc., will be testing graphical user interface applications using Cincom Smalltalk™. Features in this demonstration include: recording and replaying events, showing Smalltalk code to perform mouse/keyboard input and taking screenshots to compare with previously recorded templates.
Bio: Andreas Hiltner is currently a Lead Software Engineer for Cincom® ObjectStudio®, and has a hand in many aspects of VM, base image and database development. He works from home near Nuremberg, Germany, where he just recently returned after spending five years with his family in the US at Cincom’s headquarters in Cincinnati, Ohio.
Along with many contributions to ObjectStudio over the years, he was the project lead in Cincom’s development of the current 8.x versions of ObjectStudio, built on the Cincom Smalltalk Foundation. Andreas is a seasoned architect who has specialized in ObjectStudio for more than 15 years. In his years of working with Cincom®, he has had the opportunity to assist key Cincom Smalltalk™ users worldwide including one of the world’s top five financial institutions, and several government agencies. Andreas also accepted the responsibility of being the technical lead for ObjectStudio's Next Generation GUI Project.
Pharo
Title: Pharo
Tue, July 14, 9am – 10am
First Name: Stephane
Last Name: Ducasse
Abstract: This talk will present some exciting news about Pharo such as the birth of PharoPro a support service for Pharo. We will cover the new tools of Pharo 40 and we will show the current development effort such as event touch, new graphical kernel.
Bio: Stephane is directeur de recherche at Inria. He has more than 16 years of experience in software maintenance. He leads the RMoD (http://rmod.lille.inria.fr) team. He is expert in two domains: object-oriented language design and reengineering. He worked on traits, composable groups of methods, and this work got some impact. Traits have been introduced in Pharo, Perl, PHP and under a variant into Scala, Fortress of SUN Microsystems. He is also expert on software quality, program understanding, program visualizations, reengineering and metamodeling. He is one of the developer of Moose, an open-source software analysis platform http://www.moosetechnology.org/. He created http://www.synectique.eu/ a company building dedicated tools for advanced software analysis.
Video 1: https://www.youtube.com/watch?v=RwzwCMLFIJ8
Video 2: https://www.youtube.com/watch?v=RwzwCMLFIJ8
Viewers also liked (9)
Scratching the itch, making Scratch for the Raspberry Pie
Scratching the itch, making Scratch for the Raspberry Pie
Similar to First class Variables in Pharo
10 Groovy Little JavaScript Tips
JavaScript, like it or not, has become the most important language on the web. Nearly every developer who builds Internet apps has to use it. But JavaScript can be tough to write and even tougher to read. So here are ten tips to help you get groovy with JavaScript.
Java script
JavaScript can change HTML content, attributes, styles, and validate data. It can be placed in the <body> and <head> sections between <script> tags. Functions and events allow JavaScript code to run when events occur. JavaScript can output to alerts, the document, elements, and the console. It uses data types like numbers, strings, Booleans, arrays, and objects. Conditionals like if/else and switch statements allow different code blocks to run based on conditions. Loops like for, for/in, while, and do/while repeat code.
Slot Composition
The document discusses representing instance variables in Pharo as first-class objects called slots. It describes how slots can be composed of a storage slot and decorator slots to combine behaviors. This solves the problem of wanting to combine certain slot types, like making a observable slot that also has a default value, without exploding the number of possible slot combinations. The proposed solution is a composed slot that has one storage slot and any number of decorator slots. Decorators modify behavior before and after reads and writes, while wrappers wrap the underlying slot. Most wrappers can be implemented as decorators instead to simplify composition. Status is work in progress to reimplement all existing slots to work with this composable model.
Slot Composition
The document discusses representing instance variables in Pharo as first-class objects called slots. This allows instance variables to be customized by creating subclasses of slots. However, there is a combinatorial explosion problem when trying to combine the behaviors of different slot types. The proposed solution is to allow slots to be composed of one storage slot plus zero or more decorator slots, addressing this problem. Decorators can modify behavior before, after, or around reads and writes to the storage slot. This composition approach allows flexible combination of slot behaviors without exponential growth of subclasses.
XAML/C# to HTML/JS
This document discusses transitioning from .NET/XAML development to web development using HTML, JavaScript, and TypeScript. It covers choosing TypeScript and a MVVM framework like Knockout to leverage existing skills in data binding, object-oriented programming, and requirements handling. The document demonstrates TypeScript features like classes, inheritance, interfaces and generics. It also shows how to implement the MVVM pattern in Knockout through data binding, commands, and iterating over collections.
Refactoring
How to improve your code quality? The answer is continuous refactoring. Learn more about refactoring. Know the most frequent code smells (antipatterns), telling when to refactor. Go through the catalog of well-known refactorings, telling how to improve your code.
Cappuccino - A Javascript Application Framework
Cappuccino is a framework for building desktop-class applications for the web. It is based on Objective-J, an object-oriented language extension to Javascript.
Variables in Pharo
Variables in Pharo can now be represented as objects in a class hierarchy. This allows defining custom variable types like lazy initialized instance variables. Classes can also be defined fluidly using a cascade syntax that supports specifying variable types. The new variable system is compatible with existing Smalltalk code while enabling new capabilities and a more reflective programming model. Further work includes improving debugging and development tools to leverage the new variable abstractions.
Everything-as-code. A polyglot adventure. #DevoxxPL
As modern, agile architects and developers we need to master several different languages and technologies all at once to build state-of-the-art solutions and yet be 100% productive. We define our development environments using Gradle. We implement our software in Java, Kotlin or another JVM based language. We use Groovy or Scala to test our code at different layers. We construct the build pipelines for our software using a Groovy DSL or JSON. We use YAML and Python to describe the infrastructure and the deployment for our applications. We document our architectures using AsciiDoc and JRuby. Welcome to Babel!
Making the right choices in the multitude of available languages and technologies is not easy. Randomly combining every hip technology out there will surely lead into chaos. What we need is a customized, streamlined tool chain and technology stack that fits the project, your team and the customer’s ecosystem all at once. This code intense, polyglot session is an opinionated journey into the modern era of software industrialization.
Everything-as-code - A polyglot adventure
Devoxx 2017, Poland: Talk by Mario-Leander Reimer (@LeanderReimer, Principal Software Architect at QAware).
Abstract: As modern, agile architects and developers we need to master several different languages and technologies all at once to build state-of-the-art solutions and yet be 100% productive. We define our development environments using Gradle. We implement our software in Java, Kotlin or another JVM based language. We use Groovy or Scala to test our code at different layers. We construct the build pipelines for our software using a Groovy DSL or JSON. We use YAML and Python to describe the infrastructure and the deployment for our applications. We document our architectures using AsciiDoc and JRuby. Welcome to Babel!
Making the right choices in the multitude of available languages and technologies is not easy. Randomly combining every hip technology out there will surely lead into chaos. What we need is a customized, streamlined tool chain and technology stack that fits the project, your team and the customer’s ecosystem all at once. This code intense, polyglot session is an opinionated journey into the modern era of software industrialization.
Glorp Tutorial Guide
itle: Glorp Tutorial
Speaker: Niall Ross
Mon, August 18, 2:00pm – 3:30pm
Video Part1: https://www.youtube.com/watch?v=cPN1A4WQyiA
Video Part2: https://www.youtube.com/watch?v=25S6cSYgh34
Abstract:
The target audience for this hands-on tutorial is those with little or no Glorp experience (but more experienced people willing to pair-program with beginners are most welcome). The tutorial will help them to start using in Glorp in their own applications.
Participants will create a simple Glorp descriptor system for a domain model. They will generate a database from it, incorporating some existing legacy. They will write and read between the database and their domain model using Glorp commands. The issues of transactions, caching and refreshing will be addressed.
Java script basics
JavaScript was originally created as LiveScript in 1995 and renamed to JavaScript. It is an interpreted scripting language that can be added to HTML pages to provide dynamic interactivity. JavaScript code is executed by the browser's JavaScript engine and does not need to be compiled. It allows manipulating the structure, style, and content of HTML documents, validating form data, detecting browser capabilities, and much more.
Handlebars & Require JS
Introduction
Require JS
Handlebars
Conclusions
This presentation has been developed in the context of the Mobile Applications Development course, DISIM, University of L'Aquila (Italy), Spring 2015.
http://www.ivanomalavolta.com
Introduction to JavaScript
This document provides an introduction to JavaScript, covering topics such as:
- The scope of the lesson includes an introduction to JavaScript, using JavaScript code, syntax, data types, objects, strings, functions, and standard popup boxes.
- JavaScript is a client-side scripting language that allows interactivity on web pages by modifying HTML content and handling events. It is interpreted by web browsers rather than compiled.
- JavaScript code can be embedded directly in HTML, or linked via external .js files, and is executed when the page loads or in response to events.
Raffaele Rialdi
Raffaele Rialdi discusses building plugins for Node.js that interface with .NET Core. He covers hosting the CoreCLR from C++, building a C++ V8 addon, and introduces xcore which allows calling .NET from JavaScript/TypeScript by analyzing metadata and optimizing performance. Examples show loading CLR, creating a .NET object, and calling methods from JavaScript using xcore. Potential use cases include Node.js apps, Electron apps, scripting Powershell, and Nativescript mobile apps.
IT2255 Web Essentials - Unit III Client-Side Processing and Scripting
JavaScript Introduction – Variables and Data Types – Statements – Operators – Literals – Functions – Objects – Arrays – Built-in Objects – Regular Expression, Exceptions, Event handling, Validation – JavaScript Debuggers.
Spring Day | Spring and Scala | Eberhard Wolff
2011-10-31 | 09:45 AM - 10:30 AM
Spring is widely used in the Java world - but does it make any sense to combine it with Scala? This talk gives an answer and shows how and why Spring is useful in the Scala world. All areas of Spring such as Dependency Injection, Aspect-Oriented Programming and the Portable Service Abstraction as well as Spring MVC are covered.
JavaScript Fundamentals & JQuery
JavaScript is the world's most popular programming language. It is used to add interactive effects to web pages. JavaScript code can be inserted into HTML pages between <script> tags. Common JavaScript statements include conditional statements like if/else and loops. Variables are used to store and manipulate data in JavaScript. Common data types include strings, numbers, booleans, arrays, and objects. Functions allow code reuse and organization. Operators are used to assign values, compare values, and perform arithmetic. jQuery is a popular JavaScript library that simplifies DOM manipulation and event handling.
Awesome html with ujs, jQuery and coffeescript
The document provides an overview of HTML5, jQuery, and CoffeeScript. It discusses semantic HTML tags, unobtrusive JavaScript, jQuery features like DOM manipulation and events, and CoffeeScript features like string interpolation, functions, objects, and classes. Contact information is also included at the end.
Intro to Scala
This ppt describes basics of scala upto collections covering both object oriented and functional programming concepts of the language.
References:Scala cookbook
Similar to First class Variables in Pharo (20)
Everything-as-code. A polyglot adventure. #DevoxxPL
Everything-as-code. A polyglot adventure. #DevoxxPL
IT2255 Web Essentials - Unit III Client-Side Processing and Scripting
IT2255 Web Essentials - Unit III Client-Side Processing and Scripting
More from ESUG
Workshop: Identifying concept inventories in agile programming
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.
Technical documentation support in Pharo
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 Roadmap
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.
Sequence: Pipeline modelling in Pharo
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...
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 results
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 6
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.
A Unit Test Metamodel for Test Generation
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.
Creating Unit Tests Using Genetic Programming
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 Modes
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 Report
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 APIs
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.
Garbage Collector Tuning
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 Case
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.
Pharo DataFrame: Past, Present, and Future
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.
thisContext in the Debugger
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.
Websockets for Fencing Score
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 JavaScript
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.
Advanced Object- Oriented Design Mooc
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 Transformations
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.
More from ESUG (20)
Workshop: Identifying concept inventories in agile programming
Workshop: Identifying concept inventories in agile programming
The Pharo Debugger and Debugging tools: Advances and Roadmap
The Pharo Debugger and Debugging tools: Advances and Roadmap
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 results
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
Transpiling Pharo Classes to JS ECMAScript 5 versus ECMAScript 6
Threaded-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 Report
Pharo: a reflective language A first systematic analysis of reflective APIs
Pharo: a reflective language A first systematic analysis of reflective APIs
Improving Performance Through Object Lifetime Profiling: the DataFrame Case
Improving Performance Through Object Lifetime Profiling: the DataFrame Case
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScript
ShowUs: PharoJS.org Develop in Pharo, Run on JavaScript
A New Architecture Reconciling Refactorings and Transformations
A New Architecture Reconciling Refactorings and Transformations
Recently uploaded
Dandelion Hashtable: beyond billion requests per second on a commodity server
This slide deck presents DLHT, a concurrent in-memory hashtable. Despite efforts to optimize hashtables, that go as far as sacrificing core functionality, state-of-the-art designs still incur multiple memory accesses per request and block request processing in three cases. First, most hashtables block while waiting for data to be retrieved from memory. Second, open-addressing designs, which represent the current state-of-the-art, either cannot free index slots on deletes or must block all requests to do so. Third, index resizes block every request until all objects are copied to the new index. Defying folklore wisdom, DLHT forgoes open-addressing and adopts a fully-featured and memory-aware closed-addressing design based on bounded cache-line-chaining. This design offers lock-free index operations and deletes that free slots instantly, (2) completes most requests with a single memory access, (3) utilizes software prefetching to hide memory latencies, and (4) employs a novel non-blocking and parallel resizing. In a commodity server and a memory-resident workload, DLHT surpasses 1.6B requests per second and provides 3.5x (12x) the throughput of the state-of-the-art closed-addressing (open-addressing) resizable hashtable on Gets (Deletes).
QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...
QR Secure: A Hybrid Approach Using Machine Learning and Security Validation Functions to Prevent Interaction with Malicious QR Codes.
Aim of the Study: The goal of this research was to develop a robust hybrid approach for identifying malicious and insecure URLs derived from QR codes, ensuring safe interactions.
This is achieved through:
Machine Learning Model: Predicts the likelihood of a URL being malicious.
Security Validation Functions: Ensures the derived URL has a valid certificate and proper URL format.
This innovative blend of technology aims to enhance cybersecurity measures and protect users from potential threats hidden within QR codes 🖥 🔒
This study was my first introduction to using ML which has shown me the immense potential of ML in creating more secure digital environments!
Introducing BoxLang : A new JVM language for productivity and modularity!
Just like life, our code must adapt to the ever changing world we live in. From one day coding for the web, to the next for our tablets or APIs or for running serverless applications. Multi-runtime development is the future of coding, the future is to be dynamic. Let us introduce you to BoxLang.
Dynamic. Modular. Productive.
BoxLang redefines development with its dynamic nature, empowering developers to craft expressive and functional code effortlessly. Its modular architecture prioritizes flexibility, allowing for seamless integration into existing ecosystems.
Interoperability at its Core
With 100% interoperability with Java, BoxLang seamlessly bridges the gap between traditional and modern development paradigms, unlocking new possibilities for innovation and collaboration.
Multi-Runtime
From the tiny 2m operating system binary to running on our pure Java web server, CommandBox, Jakarta EE, AWS Lambda, Microsoft Functions, Web Assembly, Android and more. BoxLang has been designed to enhance and adapt according to it's runnable runtime.
The Fusion of Modernity and Tradition
Experience the fusion of modern features inspired by CFML, Node, Ruby, Kotlin, Java, and Clojure, combined with the familiarity of Java bytecode compilation, making BoxLang a language of choice for forward-thinking developers.
Empowering Transition with Transpiler Support
Transitioning from CFML to BoxLang is seamless with our JIT transpiler, facilitating smooth migration and preserving existing code investments.
Unlocking Creativity with IDE Tools
Unleash your creativity with powerful IDE tools tailored for BoxLang, providing an intuitive development experience and streamlining your workflow. Join us as we embark on a journey to redefine JVM development. Welcome to the era of BoxLang.
"Scaling RAG Applications to serve millions of users", Kevin Goedecke
How we managed to grow and scale a RAG application from zero to thousands of users in 7 months. Lessons from technical challenges around managing high load for LLMs, RAGs and Vector databases.
Getting the Most Out of ScyllaDB Monitoring: ShareChat's Tips
ScyllaDB monitoring provides a lot of useful information. But sometimes it’s not easy to find the root of the problem if something is wrong or even estimate the remaining capacity by the load on the cluster. This talk shares our team's practical tips on: 1) How to find the root of the problem by metrics if ScyllaDB is slow 2) How to interpret the load and plan capacity for the future 3) Compaction strategies and how to choose the right one 4) Important metrics which aren’t available in the default monitoring setup.
AppSec PNW: Android and iOS Application Security with MobSF
Mobile Security Framework - MobSF is a free and open source automated mobile application security testing environment designed to help security engineers, researchers, developers, and penetration testers to identify security vulnerabilities, malicious behaviours and privacy concerns in mobile applications using static and dynamic analysis. It supports all the popular mobile application binaries and source code formats built for Android and iOS devices. In addition to automated security assessment, it also offers an interactive testing environment to build and execute scenario based test/fuzz cases against the application.
This talk covers:
Using MobSF for static analysis of mobile applications.
Interactive dynamic security assessment of Android and iOS applications.
Solving Mobile app CTF challenges.
Reverse engineering and runtime analysis of Mobile malware.
How to shift left and integrate MobSF/mobsfscan SAST and DAST in your build pipeline.
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor Ivaniuk
At this talk we will discuss DDoS protection tools and best practices, discuss network architectures and what AWS has to offer. Also, we will look into one of the largest DDoS attacks on Ukrainian infrastructure that happened in February 2022. We'll see, what techniques helped to keep the web resources available for Ukrainians and how AWS improved DDoS protection for all customers based on Ukraine experience
Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Availab...
Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Available 24/7
Apps Break Data
How information systems are built or acquired puts information, which is what they should be about, in a secondary place. Our language adapted accordingly, and we no longer talk about information systems but applications. Applications evolved in a way to break data into diverse fragments, tightly coupled with applications and expensive to integrate. The result is technical debt, which is re-paid by taking even bigger "loans", resulting in an ever-increasing technical debt. Software engineering and procurement practices work in sync with market forces to maintain this trend. This talk demonstrates how natural this situation is. The question is: can something be done to reverse the trend?
Harnessing the Power of NLP and Knowledge Graphs for Opioid Research
Gursev Pirge, PhD
Senior Data Scientist - JohnSnowLabs
inQuba Webinar Mastering Customer Journey Management with Dr Graham Hill
HERE IS YOUR WEBINAR CONTENT! 'Mastering Customer Journey Management with Dr. Graham Hill'. We hope you find the webinar recording both insightful and enjoyable.
In this webinar, we explored essential aspects of Customer Journey Management and personalization. Here’s a summary of the key insights and topics discussed:
Key Takeaways:
Understanding the Customer Journey: Dr. Hill emphasized the importance of mapping and understanding the complete customer journey to identify touchpoints and opportunities for improvement.
Personalization Strategies: We discussed how to leverage data and insights to create personalized experiences that resonate with customers.
Technology Integration: Insights were shared on how inQuba’s advanced technology can streamline customer interactions and drive operational efficiency.
Containers & AI - Beauty and the Beast!?!
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Keywords: AI, Containeres, Kubernetes, Cloud Native
Event Link: https://meine.doag.org/events/cloudland/2024/agenda/#agendaId.4211
Northern Engraving | Modern Metal Trim, Nameplates and Appliance Panels
What began over 115 years ago as a supplier of precision gauges to the automotive industry has evolved into being an industry leader in the manufacture of product branding, automotive cockpit trim and decorative appliance trim. Value-added services include in-house Design, Engineering, Program Management, Test Lab and Tool Shops.
JavaLand 2024: Application Development Green Masterplan
My presentation slides I used at JavaLand 2024
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectors
Join us to learn how UiPath Apps can directly and easily interact with prebuilt connectors via Integration Service--including Salesforce, ServiceNow, Open GenAI, and more.
The best part is you can achieve this without building a custom workflow! Say goodbye to the hassle of using separate automations to call APIs. By seamlessly integrating within App Studio, you can now easily streamline your workflow, while gaining direct access to our Connector Catalog of popular applications.
We’ll discuss and demo the benefits of UiPath Apps and connectors including:
Creating a compelling user experience for any software, without the limitations of APIs.
Accelerating the app creation process, saving time and effort
Enjoying high-performance CRUD (create, read, update, delete) operations, for
seamless data management.
Speakers:
Russell Alfeche, Technology Leader, RPA at qBotic and UiPath MVP
Charlie Greenberg, host
LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...
This LF Energy webinar took place June 20, 2024. It featured:
-Alex Thornton, LF Energy
-Hallie Cramer, Google
-Daniel Roesler, UtilityAPI
-Henry Richardson, WattTime
In response to the urgency and scale required to effectively address climate change, open source solutions offer significant potential for driving innovation and progress. Currently, there is a growing demand for standardization and interoperability in energy data and modeling. Open source standards and specifications within the energy sector can also alleviate challenges associated with data fragmentation, transparency, and accessibility. At the same time, it is crucial to consider privacy and security concerns throughout the development of open source platforms.
This webinar will delve into the motivations behind establishing LF Energy’s Carbon Data Specification Consortium. It will provide an overview of the draft specifications and the ongoing progress made by the respective working groups.
Three primary specifications will be discussed:
-Discovery and client registration, emphasizing transparent processes and secure and private access
-Customer data, centering around customer tariffs, bills, energy usage, and full consumption disclosure
-Power systems data, focusing on grid data, inclusive of transmission and distribution networks, generation, intergrid power flows, and market settlement data
Northern Engraving | Nameplate Manufacturing Process - 2024
Manufacturing custom quality metal nameplates and badges involves several standard operations. Processes include sheet prep, lithography, screening, coating, punch press and inspection. All decoration is completed in the flat sheet with adhesive and tooling operations following. The possibilities for creating unique durable nameplates are endless. How will you create your brand identity? We can help!
Recently uploaded (20)
Dandelion Hashtable: beyond billion requests per second on a commodity server
Dandelion Hashtable: beyond billion requests per second on a commodity server
QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...
QR Secure: A Hybrid Approach Using Machine Learning and Security Validation F...
Introducing BoxLang : A new JVM language for productivity and modularity!
Introducing BoxLang : A new JVM language for productivity and modularity!
"Scaling RAG Applications to serve millions of users", Kevin Goedecke
"Scaling RAG Applications to serve millions of users", Kevin Goedecke
Getting the Most Out of ScyllaDB Monitoring: ShareChat's Tips
Getting the Most Out of ScyllaDB Monitoring: ShareChat's Tips
AppSec PNW: Android and iOS Application Security with MobSF
AppSec PNW: Android and iOS Application Security with MobSF
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor Ivaniuk
"Frontline Battles with DDoS: Best practices and Lessons Learned", Igor Ivaniuk
Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Availab...
Call Girls Chandigarh🔥7023059433🔥Agency Profile Escorts in Chandigarh Availab...
Harnessing the Power of NLP and Knowledge Graphs for Opioid Research
Harnessing the Power of NLP and Knowledge Graphs for Opioid Research
inQuba Webinar Mastering Customer Journey Management with Dr Graham Hill
inQuba Webinar Mastering Customer Journey Management with Dr Graham Hill
Northern Engraving | Modern Metal Trim, Nameplates and Appliance Panels
Northern Engraving | Modern Metal Trim, Nameplates and Appliance Panels
JavaLand 2024: Application Development Green Masterplan
JavaLand 2024: Application Development Green Masterplan
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectors
Connector Corner: Seamlessly power UiPath Apps, GenAI with prebuilt connectors
LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...
LF Energy Webinar: Carbon Data Specifications: Mechanisms to Improve Data Acc...
Northern Engraving | Nameplate Manufacturing Process - 2024
Northern Engraving | Nameplate Manufacturing Process - 2024
First class Variables in Pharo
- 1. Variables in Pharo5 ESUG 2015 Marcus Denker http://www.pharo.org
- 2. Everything is an Object
- 3. Everything?
- 5. Methods, yes
- 7. Everything is an object? SmalltalkImage classVarNamed: #CompilerClass ==> returns value Object binding class ==> Association
- 8. Why not an Object?
- 9. Globals/ClassVariables • We are close: bindings are associations • Add sublass “LiteralVariable” • Sublasses GlobalVariable, ClassVariable • Enhance API
- 11. Globals: Reflective APi global := SmalltalkImage classVariableNamed: #CompilerClass global read global write: someObject + helper methods + compatibility methods
- 12. Everything is an object? • Point instanceVariables • 5@3 instVarNamed: ‘x’ • 5@3 instVarNamed: ‘y’ put: 6
- 13. Why not an Object?
- 14. Slots Point slots (Point slotNamed: #x) read: (3@4) (Point slotNamed: #x) write: 7 to: (3@4)
- 15. Variables+MetaLink • Helper methods • But: can’t we annotate variables directly? Point assignmentNodes
- 16. Variables + Links • Object binding link: myMetaLink • (Point slotNamed: #x) link: myMetaLink (not yet in Pharo5)
- 17. Opal Compiler • Uses RB AST • Based on Visitors Text AST AST +vars IR CM Parser Semantic Analysis AST Translator+ IRBuilder BytecodeBuilder+ Encoder
- 18. Opal Compiler • Name analysis finds the variables • Code generator can delegate to them Text AST AST +vars IR CM Parser Semantic Analysis AST Translator+ IRBuilder BytecodeBuilder+ Encoder
- 19. Gobals: code read • By default compile reflective read emitValue: aMethodBuilder aMethodBuilder pushLiteralVariable: #slot->self; send: #read
- 20. Gobals: code write • By default compile reflective write emitStore: aMethodBuilder | tempName | tempName := Object new. aMethodBuilder addTemp: tempName; storeTemp: tempName; popTop; pushLiteralVariable: #global -> self; pushTemp: tempName; send: #write:
- 21. Gobals: code write • ClassVariable and GlobalVariable override emitStore: methodBuilder methodBuilder storeIntoLiteralVariable: self.
- 22. Same for Slots • Slot generates reflective read/write • InstanceVariableSlot overrides for fast instance access via byte code
- 23. What does that mean? • Slots and Globals are instances of a class • The compiler delegates code generation to the variable meta object • Which means: We can define our own variables!
- 24. Class Template Object subclass: #Point slots: { #x. #y } classVariables: { } category: 'Kernel-BasicObjects'
- 25. Class Template Object subclass: #MyClass slots: { #x => WeakSlot } classVariables: { } category: 'Example'
- 26. Examples: DEMO • Simple Slot • WeakSlot • Property Slot • Boolean
- 27. RoadMap • Pharo3: • Layout+Slots (hidden), Opal • Pharo4 • Slots: Monticello support, class template • Pharo5 • Remove old Compiler/AST • Slots + Reflectivity: First finished version
- 28. RoadMap • Pharo6: • Library of useful Slots • Use e.g. Property Slots in Bloc/Morphic
- 29. Future • Can’t we model bit patterns and bind them to named virtual slots? • How to model Array-like layouts better?
- 30. Thanks! • Work of many people… • special thanks to… Toon Verwaest, Camillo Bruni, Martin Dias, Stephane Ducasse, Max Mattone and Camille Teruel
- 31. Questions ?