2 - OOP
Download as ppt, pdf2 likes1,329 views
This document discusses the history and concepts of the Smalltalk programming language. Smalltalk was developed in the 1970s and was highly influential as one of the earliest object-oriented languages. It featured a simple uniform syntax, with everything represented as an object that communicates through message passing. Smalltalk also introduced fundamental concepts like classes, inheritance, polymorphism, and dynamic typing.
1 of 16
Downloaded 26 times
![S.Ducasse 12
Messages and Methods
Message:What behavior to perform
aWorkstation accept: aPacket
aMonter eat: aCookie
Method: How to carry out the behaviour
accept: aPacket
(aPacket isAddressedTo: self)
ifTrue:[ Transcript show: 'A packet is accepted by
the Workstation ', self name asString]
ifFalse: [super accept: aPacket]](https://image.slidesharecdn.com/stoop-002-history-101025032452-phpapp01/85/2-OOP-12-320.jpg)
Ad
Recommended
4 - OOP - Taste of Smalltalk (VisualWorks)
4 - OOP - Taste of Smalltalk (VisualWorks)The World of Smalltalk A message is a request sent from one object to another to perform an action. It consists of a receiver, selector, and arguments. The receiver is the object receiving the message. The selector identifies the method to be called. Methods are defined by specifying the selector, arguments, and method body. Classes are defined by specifying the superclass, instance variables, and methods. Everything in Smalltalk is an object that communicates through message passing.
3 - OOP - Runtime
3 - OOP - RuntimeThe World of Smalltalk 1. The Smalltalk runtime architecture consists of a virtual machine, image, and changes/sources. The image contains bytecode and sources/changes contain code text.
2. All changes are recorded so developers should have change recovery tools to avoid losing code. Code is not stored in source files but in the image and changes.
3. For deployment, the image is stripped of development components like sources/changes leaving just bytecode to be run on the virtual machine.
1 - OOP
1 - OOPThe World of Smalltalk This document discusses object-oriented programming and modeling. It introduces key concepts like objects, classes, inheritance, and how they help address the inherent complexity in software as it evolves over time. Objects encapsulate both data and behavior, and classes define common properties and behaviors for groups of objects. Inheritance allows classes to share and specialize behaviors through subclass hierarchies. Together, these concepts provide abstraction and reuse capabilities that help manage complexity in software systems.
OCaml Labs introduction at OCaml Consortium 2012
OCaml Labs introduction at OCaml Consortium 2012Anil Madhavapeddy The document summarizes a meeting of the OCaml Consortium in November 2012. It discusses plans to create an OCaml Platform that combines the core compiler with libraries, tools, and documentation. This will include launching ocaml.org with sites for documentation, packages, mailing lists, and events. It also describes the ongoing work on OPAM and hosting its package repository, along with expanding support for different operating systems.
Intro to HTML5 Game Programming
Intro to HTML5 Game ProgrammingJames Williams The document provides an introduction and agenda for a talk on HTML5 game programming. The talk will cover HTML5 basics like application cache, web workers, web sockets, and storage technologies. It will then dive into Canvas 2D drawing, including shapes, paths, fonts, images, and pixel manipulation. The speaker will demonstrate creating a tic-tac-toe game with Canvas, including drawing the board, X's, and O's. The talk will also cover using the Canvas to work with video.
Cloudstack collaboration conference Europe - SDN and Devops
Cloudstack collaboration conference Europe - SDN and DevopsJohn Willis The document provides an overview of a presentation on how software defined networking (SDN) could be the next frontier for DevOps. It begins with introducing SDN concepts like decoupling the control plane from the data plane. It then discusses lessons learned from DevOps and how those same principles could apply to SDN and network operations. Lastly, it envisions what an SDN and DevOps world might look like, with network operations adopting practices like infrastructure as code that have benefited systems operations.
Docker 1 0 1 0 1: a Docker introduction, actualized for the stable release of...
Docker 1 0 1 0 1: a Docker introduction, actualized for the stable release of...Jérôme Petazzoni The document details a presentation on Docker, discussing its significance, functionality, and the benefits of using containers for deployment across various environments. It covers Docker's architecture, community involvement, and various deployment options, emphasizing efficiency and consistency in application management. Additionally, it highlights Docker’s continuous improvements and upcoming features, catering to developers and operations personnel alike.
04 idioms
04 idiomsThe World of Smalltalk This document discusses Smalltalk coding idioms and best practices. It covers topics like:
- Using cascades and the "yourself" message to chain messages to the same receiver.
- Distributing responsibilities across many small, carefully named methods to promote reuse and maintainability.
- Techniques for initializing objects, establishing class invariants, and representing instance creation.
- Debugging techniques like printing an object's state.
The document provides code examples and explanations for common patterns in Smalltalk, such as initializing instance variables, creating collection objects, and defining constructor and accessor methods. It is intended as a guide for writing well-structured and maintainable Smalltalk code.
Concurrency in Smalltalk -- Beyond Threads
Concurrency in Smalltalk -- Beyond ThreadsESUG 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.
8 - OOP - Syntax & Messages
8 - OOP - Syntax & MessagesThe World of Smalltalk The document provides an introduction to the syntax and semantics of the Smalltalk programming language. It summarizes literals like numbers, strings, arrays, variables, assignments, returns, pseudo-variables, message expressions, block expressions, and conditionals and loops. The summary focuses on key concepts like objects communicating through message passing, different types of messages, variable scope, and blocks acting as anonymous methods.
02 basics
02 basicsThe World of Smalltalk Smalltalk is an object-oriented programming language where everything is an object and communication is done through message passing. The document discusses Smalltalk basics including its syntax, variables, methods, blocks, control structures and more. It provides a roadmap for learning Smalltalk and examples to illustrate Smalltalk concepts.
5 - OOP - Smalltalk in a Nutshell (a)
5 - OOP - Smalltalk in a Nutshell (a)The World of Smalltalk The document discusses Smalltalk's object-oriented model. The key points are:
1) Everything in Smalltalk is an object, including classes.
2) There is only one inheritance hierarchy - classes inherit from one another in the same way as regular objects.
3) Methods are public, while instance variables are private to their class and protected in subclasses.
4) Lookup works the same for all objects - messages are sent and handled by the receiver's class.
13 traits
13 traitsThe World of Smalltalk This document provides an overview of traits in programming. It discusses the limitations of single and multiple inheritance, as well as mixins. Traits are introduced as a way to share behavior across class hierarchies without these issues. Key points about traits are that they provide methods but no state, and classes have full control over trait composition. The document also presents a case study on refactoring stream classes using traits for improved reuse and design. It concludes with discussion on the implementation of traits in Pharo and potential future directions.
05 seaside canvas
05 seaside canvasThe World of Smalltalk The document describes brush hierarchies and attributes for canvas and tags in HTML. It defines hierarchies for canvas, brushes and tags. It lists the factory selector, brush class and attribute accessors for various tag brushes. This includes div, fieldset, form inputs, buttons, tables and other tags. It provides the classes and methods to represent and manipulate these elements when building HTML documents.
3 - OOP - VisualWorks (a)
3 - OOP - VisualWorks (a)The World of Smalltalk This document discusses the runtime architecture and development environment of the Smalltalk virtual machine. The runtime architecture consists of bytecodes stored in an image file that are executed by the virtual machine. Sources and changes are stored separately and are removed after development. The development environment allows browsing and inspecting classes and objects, debugging, and integrated version control for code management.
3 - OOP - VisualWorks (b)
3 - OOP - VisualWorks (b)The World of Smalltalk The document discusses the runtime architecture of Smalltalk. It notes that the runtime consists of a virtual machine, image, and sources. The image contains bytecodes that are translated to native code by a just-in-time compiler at runtime. Sources and changes are not needed for execution and are typically removed for deployment. An application can be delivered as bytecode files to be executed by the virtual machine.
Smalltalk In a Nutshell
Smalltalk In a NutshellMichele Lanza The document provides an introduction to the Smalltalk programming language, describing its origins at Xerox PARC in the 1970s, key concepts such as everything being an object and the use of images, and concluding with recommendations for further reading on Smalltalk.
01 intro
01 introThe World of Smalltalk This document provides an introduction to the Smalltalk programming language and environment. It outlines the course schedule and goals, which include learning about Smalltalk's history and object-oriented model, as well as concepts like classes, metaclasses, reflection, and advanced design patterns. The document discusses Smalltalk's origins at Xerox PARC and the key ideas it was influenced by. It also describes Smalltalk's pure object model where everything is an object that communicates through message passing. Finally, it provides an overview of the Smalltalk development environment and tools like the browser, debugger, and inspector.
Smalltalk speaks dot net
Smalltalk speaks dot netESUG This document provides an overview of Georg Heeg eK, a consulting and training company focused on Smalltalk. It discusses the history and current state of Smalltalk, opportunities for integrating Smalltalk and .NET technologies via an approach called DotNETConnect, and the future of Smalltalk platforms gaining mobility.
Agile Development with Smalltalk - Long
Agile Development with Smalltalk - LongTomáš Kukol This presentation provides an overview of Smalltalk as an object-oriented programming language and object database for agile development. Smalltalk offers a simple yet powerful language with object persistence built into the language. It allows developers to focus on business logic and processes rather than data access layers. Smalltalk also enables productive development through its integrated IDE and support for agile practices like test-driven development and refactoring.
Smalltalk and ruby - 2012-12-08
Smalltalk and ruby - 2012-12-08Koan-Sin Tan This document summarizes an amateur Smalltalk user's observations about Ruby's object model and bytecode freedom based on a presentation given in Taiwan. It begins with an introduction and outline. It then discusses the speaker's background in Smalltalk and Ruby. The remainder of the document explores Smalltalk-80's object model in detail and compares it to Ruby's object model and metaclass hierarchy.
Exploring metaprogramming using Ruby language
Exploring metaprogramming using Ruby languageHarshal Hayatnagarkar The document provides an introduction to metaprogramming using the Ruby programming language, explaining its concepts, including reflection and generative programming. It discusses Ruby's dynamic and reflective nature, highlighting how it allows programs to treat code as data for increased flexibility and productivity. Additionally, it addresses potential challenges of metaprogramming, such as increased complexity and the possibility of generating ‘metabugs’.
Smalltalk and Business
Smalltalk and BusinessMariano Martínez Peck The document discusses Smalltalk and its use in business. It provides an overview of Smalltalk, including its history and inventions. It describes dialects like Pharo and how it can be used for web development, databases, and more. Benefits include productivity, flexibility, and being fully object-oriented, while disadvantages include lack of mainstream popularity and documentation compared to other languages.
5 - OOP - Smalltalk in a Nutshell (b)
5 - OOP - Smalltalk in a Nutshell (b)The World of Smalltalk The document discusses Smalltalk syntax and object-oriented model in brief. It notes that in Smalltalk everything is an object, with only message passing and late binding. Classes are also objects, with a single inheritance hierarchy. Methods are public and instance variables private. Lookup follows the single inheritance chain by sending messages to the class of the receiver.
Smalltalk, the dynamic language
Smalltalk, the dynamic languagemohamedsamyali The document discusses Smalltalk, one of the first object-oriented programming languages, and its influence on various modern languages such as C++, Java, and Python. It covers its key features, syntax, and concepts of pure object-oriented programming, including dynamic typing, blocks, and symbols, along with applications in education and web frameworks. Additionally, it highlights the importance of reflection, runtime class modification, and the integration of Smalltalk principles in contemporary tools and environments.
From concept to cloud a look at modern software development
From concept to cloud a look at modern software developmentSoftware Guru The document explores the evolution of software development, from early computing to modern cloud computing and programming practices. It discusses the transition from monolithic architectures to modular, polyglot application designs that leverage various programming languages and technologies. Key concepts include the limitations of traditional relational databases, the rise of NoSQL databases, and the impact of cloud services on application deployment and scalability.
4 - OOP - Taste of Smalltalk (Squeak)
4 - OOP - Taste of Smalltalk (Squeak)The World of Smalltalk 1) A message is a request sent from one object to another to execute a method.
2) The message receiver is the object that receives the message.
3) The method selector is the name of the method being called in the message.
Stoop 305-reflective programming5
Stoop 305-reflective programming5The World of Smalltalk The document discusses various techniques for implementing reflection in object-oriented programming languages like Smalltalk. It describes approaches for controlling message passing through minimal objects, anonymous classes, and method substitution. Minimal objects intercept messages using doesNotUnderstand:, while anonymous classes are inserted between instances and their classes to control lookup. Method substitution directly replaces methods to add control. The document analyzes the tradeoffs of different reflective approaches.
7 - OOP - OO Concepts
7 - OOP - OO ConceptsThe World of Smalltalk This document provides an introduction to essential object-oriented concepts including objects, classes, inheritance, composition, and comparison. It discusses how object-oriented programming views the world as interacting objects and focuses on encapsulating data and procedures while promoting modularity and reuse through concepts like classes, inheritance, polymorphism and late binding.
3 - OOP - Squeak
3 - OOP - SqueakThe World of Smalltalk This document discusses the Smalltalk runtime architecture and environment. It explains that the Smalltalk runtime consists of a virtual machine, image, and sources. The image contains bytecodes that are executed by the virtual machine. Sources and changes are the code files. For deployment, the sources and changes are removed from the image, which then only needs the virtual machine to run. The document also covers various Smalltalk development tools like the debugger, inspector, browser and Monticello version control system.
More Related Content
Viewers also liked (6)
Concurrency in Smalltalk -- Beyond Threads
Concurrency in Smalltalk -- Beyond ThreadsESUG 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.
8 - OOP - Syntax & Messages
8 - OOP - Syntax & MessagesThe World of Smalltalk The document provides an introduction to the syntax and semantics of the Smalltalk programming language. It summarizes literals like numbers, strings, arrays, variables, assignments, returns, pseudo-variables, message expressions, block expressions, and conditionals and loops. The summary focuses on key concepts like objects communicating through message passing, different types of messages, variable scope, and blocks acting as anonymous methods.
02 basics
02 basicsThe World of Smalltalk Smalltalk is an object-oriented programming language where everything is an object and communication is done through message passing. The document discusses Smalltalk basics including its syntax, variables, methods, blocks, control structures and more. It provides a roadmap for learning Smalltalk and examples to illustrate Smalltalk concepts.
5 - OOP - Smalltalk in a Nutshell (a)
5 - OOP - Smalltalk in a Nutshell (a)The World of Smalltalk The document discusses Smalltalk's object-oriented model. The key points are:
1) Everything in Smalltalk is an object, including classes.
2) There is only one inheritance hierarchy - classes inherit from one another in the same way as regular objects.
3) Methods are public, while instance variables are private to their class and protected in subclasses.
4) Lookup works the same for all objects - messages are sent and handled by the receiver's class.
13 traits
13 traitsThe World of Smalltalk This document provides an overview of traits in programming. It discusses the limitations of single and multiple inheritance, as well as mixins. Traits are introduced as a way to share behavior across class hierarchies without these issues. Key points about traits are that they provide methods but no state, and classes have full control over trait composition. The document also presents a case study on refactoring stream classes using traits for improved reuse and design. It concludes with discussion on the implementation of traits in Pharo and potential future directions.
05 seaside canvas
05 seaside canvasThe World of Smalltalk The document describes brush hierarchies and attributes for canvas and tags in HTML. It defines hierarchies for canvas, brushes and tags. It lists the factory selector, brush class and attribute accessors for various tag brushes. This includes div, fieldset, form inputs, buttons, tables and other tags. It provides the classes and methods to represent and manipulate these elements when building HTML documents.
Similar to 2 - OOP (20)
3 - OOP - VisualWorks (a)
3 - OOP - VisualWorks (a)The World of Smalltalk This document discusses the runtime architecture and development environment of the Smalltalk virtual machine. The runtime architecture consists of bytecodes stored in an image file that are executed by the virtual machine. Sources and changes are stored separately and are removed after development. The development environment allows browsing and inspecting classes and objects, debugging, and integrated version control for code management.
3 - OOP - VisualWorks (b)
3 - OOP - VisualWorks (b)The World of Smalltalk The document discusses the runtime architecture of Smalltalk. It notes that the runtime consists of a virtual machine, image, and sources. The image contains bytecodes that are translated to native code by a just-in-time compiler at runtime. Sources and changes are not needed for execution and are typically removed for deployment. An application can be delivered as bytecode files to be executed by the virtual machine.
Smalltalk In a Nutshell
Smalltalk In a NutshellMichele Lanza The document provides an introduction to the Smalltalk programming language, describing its origins at Xerox PARC in the 1970s, key concepts such as everything being an object and the use of images, and concluding with recommendations for further reading on Smalltalk.
01 intro
01 introThe World of Smalltalk This document provides an introduction to the Smalltalk programming language and environment. It outlines the course schedule and goals, which include learning about Smalltalk's history and object-oriented model, as well as concepts like classes, metaclasses, reflection, and advanced design patterns. The document discusses Smalltalk's origins at Xerox PARC and the key ideas it was influenced by. It also describes Smalltalk's pure object model where everything is an object that communicates through message passing. Finally, it provides an overview of the Smalltalk development environment and tools like the browser, debugger, and inspector.
Smalltalk speaks dot net
Smalltalk speaks dot netESUG This document provides an overview of Georg Heeg eK, a consulting and training company focused on Smalltalk. It discusses the history and current state of Smalltalk, opportunities for integrating Smalltalk and .NET technologies via an approach called DotNETConnect, and the future of Smalltalk platforms gaining mobility.
Agile Development with Smalltalk - Long
Agile Development with Smalltalk - LongTomáš Kukol This presentation provides an overview of Smalltalk as an object-oriented programming language and object database for agile development. Smalltalk offers a simple yet powerful language with object persistence built into the language. It allows developers to focus on business logic and processes rather than data access layers. Smalltalk also enables productive development through its integrated IDE and support for agile practices like test-driven development and refactoring.
Smalltalk and ruby - 2012-12-08
Smalltalk and ruby - 2012-12-08Koan-Sin Tan This document summarizes an amateur Smalltalk user's observations about Ruby's object model and bytecode freedom based on a presentation given in Taiwan. It begins with an introduction and outline. It then discusses the speaker's background in Smalltalk and Ruby. The remainder of the document explores Smalltalk-80's object model in detail and compares it to Ruby's object model and metaclass hierarchy.
Exploring metaprogramming using Ruby language
Exploring metaprogramming using Ruby languageHarshal Hayatnagarkar The document provides an introduction to metaprogramming using the Ruby programming language, explaining its concepts, including reflection and generative programming. It discusses Ruby's dynamic and reflective nature, highlighting how it allows programs to treat code as data for increased flexibility and productivity. Additionally, it addresses potential challenges of metaprogramming, such as increased complexity and the possibility of generating ‘metabugs’.
Smalltalk and Business
Smalltalk and BusinessMariano Martínez Peck The document discusses Smalltalk and its use in business. It provides an overview of Smalltalk, including its history and inventions. It describes dialects like Pharo and how it can be used for web development, databases, and more. Benefits include productivity, flexibility, and being fully object-oriented, while disadvantages include lack of mainstream popularity and documentation compared to other languages.
5 - OOP - Smalltalk in a Nutshell (b)
5 - OOP - Smalltalk in a Nutshell (b)The World of Smalltalk The document discusses Smalltalk syntax and object-oriented model in brief. It notes that in Smalltalk everything is an object, with only message passing and late binding. Classes are also objects, with a single inheritance hierarchy. Methods are public and instance variables private. Lookup follows the single inheritance chain by sending messages to the class of the receiver.
Smalltalk, the dynamic language
Smalltalk, the dynamic languagemohamedsamyali The document discusses Smalltalk, one of the first object-oriented programming languages, and its influence on various modern languages such as C++, Java, and Python. It covers its key features, syntax, and concepts of pure object-oriented programming, including dynamic typing, blocks, and symbols, along with applications in education and web frameworks. Additionally, it highlights the importance of reflection, runtime class modification, and the integration of Smalltalk principles in contemporary tools and environments.
From concept to cloud a look at modern software development
From concept to cloud a look at modern software developmentSoftware Guru The document explores the evolution of software development, from early computing to modern cloud computing and programming practices. It discusses the transition from monolithic architectures to modular, polyglot application designs that leverage various programming languages and technologies. Key concepts include the limitations of traditional relational databases, the rise of NoSQL databases, and the impact of cloud services on application deployment and scalability.
4 - OOP - Taste of Smalltalk (Squeak)
4 - OOP - Taste of Smalltalk (Squeak)The World of Smalltalk 1) A message is a request sent from one object to another to execute a method.
2) The message receiver is the object that receives the message.
3) The method selector is the name of the method being called in the message.
Stoop 305-reflective programming5
Stoop 305-reflective programming5The World of Smalltalk The document discusses various techniques for implementing reflection in object-oriented programming languages like Smalltalk. It describes approaches for controlling message passing through minimal objects, anonymous classes, and method substitution. Minimal objects intercept messages using doesNotUnderstand:, while anonymous classes are inserted between instances and their classes to control lookup. Method substitution directly replaces methods to add control. The document analyzes the tradeoffs of different reflective approaches.
7 - OOP - OO Concepts
7 - OOP - OO ConceptsThe World of Smalltalk This document provides an introduction to essential object-oriented concepts including objects, classes, inheritance, composition, and comparison. It discusses how object-oriented programming views the world as interacting objects and focuses on encapsulating data and procedures while promoting modularity and reuse through concepts like classes, inheritance, polymorphism and late binding.
3 - OOP - Squeak
3 - OOP - SqueakThe World of Smalltalk This document discusses the Smalltalk runtime architecture and environment. It explains that the Smalltalk runtime consists of a virtual machine, image, and sources. The image contains bytecodes that are executed by the virtual machine. Sources and changes are the code files. For deployment, the sources and changes are removed from the image, which then only needs the virtual machine to run. The document also covers various Smalltalk development tools like the debugger, inspector, browser and Monticello version control system.
F-Script
F-ScriptESUG The document discusses F-Script, a scripting language for Mac OS X. It provides a lightweight interactive and scripting layer on top of Cocoa. F-Script emphasizes interactive, high-level manipulation of objects rather than class development. It allows direct access to core Mac OS X technologies through Cocoa while using a Smalltalk-like syntax that is familiar to programmers.
4 - OOP - Taste of Smalltalk (Tamagoshi)
4 - OOP - Taste of Smalltalk (Tamagoshi)The World of Smalltalk 1) A message is a request sent from one object to another to execute a method.
2) The message receiver is the object that receives the message.
3) The method selector is the name of the method being called in the message.
Smalltalk uses only message passing between objects to perform operations.
Evolution of Programming Languages.pdf
Evolution of Programming Languages.pdfMadurai Kamaraj University Madurai Tamil Nadu India The document provides a detailed history of programming languages from the 1940s to the projected future. It discusses the evolution of early machine codes and pseudocodes in the 1940s-1950s that paved the way for higher-level languages. Major milestones included the introduction of FORTRAN in 1957, which was one of the first high-level languages, followed by an explosion of new languages in the 1960s. The 1970s saw a focus on simplicity and abstraction with languages like Pascal. Object-oriented programming emerged in the 1980s with C++ and Smalltalk. The rise of the internet in the 1990s drove increased use of scripting languages and the creation of Java. Looking ahead, the future remains uncertain but programming continues
Evolution of Programming Languages.pdf
Evolution of Programming Languages.pdfMadurai Kamaraj University Madurai Tamil Nadu India The document provides a history of programming languages from the 1940s to the projected year 2100. It discusses early pioneers and the first programming language as well as the evolution of programming languages throughout each decade. Popular modern languages discussed include Python, Java, R, Julia, Lisp, JavaScript, C++, and Mojo in the context of artificial intelligence and machine learning. The document takes a high-level view of the evolution of programming over eight decades from the 1940s to 2000s and looks ahead to future trends.
Ad
More from The World of Smalltalk (20)
99 questions
99 questionsThe World of Smalltalk This document provides an overview of the key concepts in the Smalltalk programming language. It discusses how Smalltalk is a fully reflective, dynamic object-oriented programming environment. Smalltalk uses a simple uniform object model that allows for live, dynamic and interactive software development. The document outlines various Smalltalk basics like syntax, standard classes, coding idioms, debugging practices, design patterns and more. It also covers advanced topics like reflection and how the Smalltalk meta-model is reified through reflection.
12 virtualmachine
12 virtualmachineThe World of Smalltalk This document discusses virtual machines and their implementation. It begins with an introduction to virtual machines, noting that they provide an abstract computing architecture that supports programming languages in a hardware-independent way. It then outlines the main components of a virtual machine, including the heap store, interpreter, automatic memory management, and threading system. The document dives into more detail on each of these components and also discusses optimizations that can be performed. It concludes by noting that while virtual machines provide benefits like platform independence, there is an overhead to their execution.
11 bytecode
11 bytecodeThe World of Smalltalk This document provides an overview of working with bytecode in Pharo. It discusses:
- The Pharo compiler and how it translates code to an abstract syntax tree (AST), intermediate representation (IR), and finally bytecode.
- Generating bytecode using the IRBuilder tool, which allows defining bytecode instructions like stack operations, jumps, sends, and accessing variables.
- Parsing and interpreting bytecode using the InstructionStream hierarchy, which allows analyzing, printing, and decompiling bytecode.
10 reflection
10 reflectionThe World of Smalltalk Reflection allows programs to examine and modify their own structure and behavior at runtime. The document discusses introspection, which allows observing an object's state, and intercession, which enables modifying execution state. It covers reification, representing runtime concepts as objects, and how this enables metaprogramming to manipulate a running system. Key topics are reflective capabilities in various languages, structural versus behavioral reflection, and how reflection is implemented using metaobjects and metaclasses.
09 metaclasses
09 metaclassesThe World of Smalltalk 1. The document discusses metaclasses in Smalltalk and provides 7 key points about their structure and relationships.
2. Every class is an instance of a metaclass, and the metaclass hierarchy parallels the class hierarchy. The metaclass of every class inherits from Class.
3. Metaclasses inherit from Class and Behavior. The Metaclass represents metaclass behavior and its sole instance is the metaclass of every class.
08 refactoring
08 refactoringThe World of Smalltalk This document provides an overview of refactoring and design patterns. It begins with some principles of object-oriented design like the open-closed principle. It then defines refactoring as changing code without altering external behavior to improve structure. Common code smells that indicate needs for refactoring are described, like duplicated code. The document outlines the Law of Demeter and provides examples of violations. It concludes by introducing design patterns and focusing on the singleton pattern.
07 bestpractice
07 bestpracticeThe World of Smalltalk This document discusses various best practice patterns for object-oriented programming in Smalltalk, including:
1. Naming conventions for classes, methods, variables and parameters to clearly indicate their purpose and role.
2. Using delegation to share implementation between classes without inheritance. Delegation patterns include simple delegation, self delegation, and reversing methods.
3. Double dispatch and method objects for handling multiple cases through message passing rather than conditionals.
4. Lazy initialization, caching, and conversion methods to optimize performance of expensive computations.
5. Patterns for collections, intervals and streams including comparing and ordering objects.
06 debugging
06 debuggingThe World of Smalltalk The document provides guidance on debugging in Smalltalk. It discusses common syntactic, semantic, and encapsulation errors. It also covers debugging patterns such as using print statements, tests, inspectors, breakpoints, and debuggers to debug code. The document emphasizes that the debugger, inspector, browser, and message name finder are useful debugging tools and that tests are important to prevent regressions when debugging. It also notes some best practices like avoiding modifying collections during iteration, using accessors to encapsulate state, and not referencing class names directly.
05 seaside
05 seasideThe World of Smalltalk This document provides an overview of the Seaside web application framework. It discusses key Seaside concepts like components, control flow, composition, and more. The document contains lecture notes on Seaside, including roadmaps, explanations of concepts, code examples, and screenshots.
03 standardclasses
03 standardclassesThe World of Smalltalk The document discusses Smalltalk standard classes. It covers the Object class which defines common behavior for all objects. Number classes are described, including automatic coercion between types. Strings and arrays are also covered, including literal and regular array creation. Variable types like global, instance, and block variables are explained. Control structures are implemented through message passing and blocks. Various collection classes are introduced at the end.
Stoop sed-smells
Stoop sed-smellsThe World of Smalltalk This document discusses several basic design principles and smells:
- A class should have a single responsibility and minimize access to its data.
- Inheritance should represent an "is-a" relationship, not be used for implementation convenience.
- Methods should not expose implementation details and overuse of conversions should be avoided.
- Missing information should be handled gracefully rather than raising errors.
- Nil values should be avoided by returning empty collections instead.
- Objects rather than strings or tuples should be used to represent data.
- The tell-don't-ask principle of using polymorphism rather than conditionals on types should be followed.
- Encapsulation should be maintained by not overusing accessors and
Stoop sed-sharing ornot
Stoop sed-sharing ornotThe World of Smalltalk The document discusses the design of the Scanner class in Smalltalk. It summarizes that the Scanner class has an instance variable (typeTable) and a class variable (TypeTable) that both refer to the type table object. The class variable TypeTable is used to initialize the type table once, while each scanner instance uses its own typeTable variable that can be customized if needed. This allows the type table to be shared and initialized only once, while also allowing instances to customize it if they want via copying the table.
Stoop sed-class initialization
Stoop sed-class initializationThe World of Smalltalk The document discusses class initialization in object-oriented programming. It explains that class initialization is used to initialize class variables and instance variables when a class is loaded. The class initialization method, which in Squeak is named 'initialize', is automatically called by the system at load time or can be explicitly called by the programmer. It provides an example of a Date class initialization method that initializes various class variables with data like month names and numbers of days in each month.
Stoop sed-class initialization
Stoop sed-class initializationThe World of Smalltalk The document discusses class initialization in object-oriented programming. It explains that class initialization is used to initialize class variables and instance variables when a class is loaded. The class initialization method, typically named "initialize", is automatically called by the system and can be used to set up default values for properties that are shared across all class instances. The document provides an example Date class that defines various class variables for storing things like month names and days in a month, and initializes these values in its Date class>>initialize method.
Stoop metaclasses
Stoop metaclassesThe World of Smalltalk The document discusses metaclasses in Smalltalk. Some key points:
1. Every class is an instance of a metaclass. The metaclass hierarchy parallels the class hierarchy.
2. Metaclasses inherit from Class and Behavior. Every metaclass is an instance of Metaclass.
3. The metaclass of Metaclass is also an instance of Metaclass, completing the metaclass hierarchy.
Stoop ed-unit ofreuse
Stoop ed-unit ofreuseThe World of Smalltalk This document discusses using hook and template methods to improve code reuse in object-oriented programs. Hook methods provide places where subclasses can insert specialized behavior, while template methods provide reusable context. Examples show hook methods like printOn: and postCopy that subclasses can override to customize object printing and copying behavior. Template methods like printString and copy provide reusable context by calling the hook methods. This approach allows code to be reused while still allowing customization in subclasses.
Stoop ed-subtyping subclassing
Stoop ed-subtyping subclassingThe World of Smalltalk This document discusses the differences between subclassing and subtyping in object-oriented design. It explains that subclassing is using inheritance primarily for code reuse, even if the subclass interface is not compatible with the superclass interface. Subtyping uses inheritance to reuse interface specifications so that subclasses are substitutable for their superclasses. The document recommends favoring subtyping over subclassing for reusable software since it leads to more understandable class relationships based on interfaces rather than implementation.
Stoop ed-some principles
Stoop ed-some principlesThe World of Smalltalk The document discusses several principles of software design including:
1) The open-closed principle which states that code should be open for extension but closed for modification.
2) The dependency inversion principle which states that high level modules should not depend on low level modules and both should depend on abstractions.
3) The interface segregation principle which states that dependencies should depend on the smallest possible interface to avoid "fat" interfaces.
4) The acyclic dependency principle which states that dependency structures between packages should not contain cyclic dependencies.
Stoop ed-lod
Stoop ed-lodThe World of Smalltalk The document discusses coupling and the Law of Demeter principle, which states that objects should only communicate with their immediate neighbors. Following this principle leads to code with looser coupling, better encapsulation, and easier substitution of components. The document provides examples of correct and incorrect ways to follow the Law of Demeter when sending messages to instance variables, arguments, self, and newly created objects. It also discusses some exceptions like collections, as well as considerations around using accessors instead of direct instance variable access. Overall it emphasizes designing objects with complete interfaces that protect encapsulation.
Stoop ed-inheritance composition
Stoop ed-inheritance compositionThe World of Smalltalk The document discusses different approaches to structuring code for a text formatting editor, including inheritance, composition, and delegation. It notes some drawbacks of inheritance like difficulty changing policies at runtime and responsibility not being clear. Composition is recommended instead as it allows changing strategies at runtime, has clear responsibility between components, and avoids code bloat. Delegation to other objects using strategies is given as an example implementation.
Ad
Recently uploaded (20)
How to Manage Upselling of Subscriptions in Odoo 18
How to Manage Upselling of Subscriptions in Odoo 18Celine George Subscriptions in Odoo 18 are designed to auto-renew indefinitely, ensuring continuous service for customers. However, businesses often need flexibility to adjust pricing or quantities based on evolving customer needs.
Exploring Ocean Floor Features for Middle School
Exploring Ocean Floor Features for Middle SchoolMarie This 16 slide science reader is all about ocean floor features. It was made to use with middle school students.
You can download the PDF at thehomeschooldaily.com
Thanks! Marie
How to Manage Multi Language for Invoice in Odoo 18
How to Manage Multi Language for Invoice in Odoo 18Celine George Odoo supports multi-language functionality for invoices, allowing you to generate invoices in your customers’ preferred languages. Multi-language support for invoices is crucial for businesses operating in global markets or dealing with customers from different linguistic backgrounds.
2025 June Year 9 Presentation: Subject selection.pptx
2025 June Year 9 Presentation: Subject selection.pptxmansk2 2025 June Year 9 Presentation: Subject selection
Publishing Your Memoir with Brooke Warner
Publishing Your Memoir with Brooke WarnerBrooke Warner Brooke Warner presents on getting published - traditional, hybrid, and self-publishing.
www.memoirnation.com
Overview of Employee in Odoo 18 - Odoo Slides
Overview of Employee in Odoo 18 - Odoo SlidesCeline George The employee module is a core component of the HR workspace that helps the business to get the employee activities and details. This would also allow you to get the employee details by acting as a centralized system and accessing, updating, and managing all the other employee data.
How to Implement Least Package Removal Strategy in Odoo 18 Inventory
How to Implement Least Package Removal Strategy in Odoo 18 InventoryCeline George In Odoo, the least package removal strategy is a feature designed to optimize inventory management by minimizing the number of packages open to fulfill the orders. This strategy is particularly useful for the business that deals with products packages in various quantities such as boxes, cartons or palettes.
How to Manage & Create a New Department in Odoo 18 Employee
How to Manage & Create a New Department in Odoo 18 EmployeeCeline George In Odoo 18's Employee module, organizing your workforce into departments enhances management and reporting efficiency. Departments are a crucial organizational unit within the Employee module.
Measuring, learning and applying multiplication facts.
Measuring, learning and applying multiplication facts.cgilmore6 Slides from a presentation by Professor Camilla Gilmore to the Association of Teachers of Mathematics and Mathematics Association Primary Interest group in June 2025.
This gave an overview of two studies that investigated children's multiplication fact knowledge. These studies were part of the SUM research project based at the University of Nottingham and Loughborough University. For more information see www.sumproject.org.uk
Paper 108 | Thoreau’s Influence on Gandhi: The Evolution of Civil Disobedience
Paper 108 | Thoreau’s Influence on Gandhi: The Evolution of Civil DisobedienceRajdeep Bavaliya Dive into the powerful journey from Thoreau’s 19th‑century essay to Gandhi’s mass movement, and discover how one man’s moral stand became the backbone of nonviolent resistance worldwide. Learn how conscience met strategy to spark revolutions, and why their legacy still inspires today’s social justice warriors. Uncover the evolution of civil disobedience. Don’t forget to like, share, and follow for more deep dives into the ideas that changed the world.
M.A. Sem - 2 | Presentation
Presentation Season - 2
Paper - 108: The American Literature
Submitted Date: April 2, 2025
Paper Name: The American Literature
Topic: Thoreau’s Influence on Gandhi: The Evolution of Civil Disobedience
[Please copy the link and paste it into any web browser to access the content.]
Video Link: https://youtu.be/HXeq6utg7iQ
For a more in-depth discussion of this presentation, please visit the full blog post at the following link: https://rajdeepbavaliya2.blogspot.com/2025/04/thoreau-s-influence-on-gandhi-the-evolution-of-civil-disobedience.html
Please visit this blog to explore additional presentations from this season:
Hashtags:
#CivilDisobedience #ThoreauToGandhi #NonviolentResistance #Satyagraha #Transcendentalism #SocialJustice #HistoryUncovered #GandhiLegacy #ThoreauInfluence #PeacefulProtest
Keyword Tags:
civil disobedience, Thoreau, Gandhi, Satyagraha, nonviolent protest, transcendentalism, moral resistance, Gandhi Thoreau connection, social change, political philosophy
How to Configure Vendor Management in Lunch App of Odoo 18
How to Configure Vendor Management in Lunch App of Odoo 18Celine George The Vendor management in the Lunch app of Odoo 18 is the central hub for managing all aspects of the restaurants or caterers that provide food for your employees.
FIRST DAY HIGH orientation for mapeh subject in grade 10.pptx
FIRST DAY HIGH orientation for mapeh subject in grade 10.pptxGlysdiEelesor1 basic orientation of the first day high
ABCs of Bookkeeping for Nonprofits TechSoup.pdf
ABCs of Bookkeeping for Nonprofits TechSoup.pdfTechSoup Accounting can be hard enough if you haven’t studied it in school. Nonprofit accounting is actually very different and more challenging still.
Need help? Join Nonprofit CPA and QuickBooks expert Gregg Bossen in this first-time webinar and learn the ABCs of keeping books for a nonprofit organization.
Key takeaways
* What accounting is and how it works
* How to read a financial statement
* What financial statements should be given to the board each month
* What three things nonprofits are required to track
What features to use in QuickBooks to track programs and grants
Revista digital preescolar en transformación
Revista digital preescolar en transformaciónguerragallardo26 EVOLUCIÓN DEL CONTENIDO DE LA EVALUACIÓN DE LOS RECURSOS Y DE LA FORMACIÓN DE LOS DOCENTES
ROLE PLAY: FIRST AID -CPR & RECOVERY POSITION.pptx
ROLE PLAY: FIRST AID -CPR & RECOVERY POSITION.pptxBelicia R.S Role play : First Aid- CPR, Recovery position and Hand hygiene.
Scene 1: Three friends are shopping in a mall
Scene 2: One of the friend becomes victim to electric shock.
Scene 3: Arrival of a first aider
Steps:
Safety First
Evaluate the victim‘s condition
Call for help
Perform CPR- Secure an open airway, Chest compression, Recuse breaths.
Put the victim in Recovery position if unconscious and breathing normally.
How to Manage Inventory Movement in Odoo 18 POS
How to Manage Inventory Movement in Odoo 18 POSCeline George Inventory management in the Odoo 18 Point of Sale system is tightly integrated with the inventory module, offering a solution to businesses to manage sales and stock in one united system.
Paper 107 | From Watchdog to Lapdog: Ishiguro’s Fiction and the Rise of “Godi...
Paper 107 | From Watchdog to Lapdog: Ishiguro’s Fiction and the Rise of “Godi...Rajdeep Bavaliya Dive into a captivating analysis where Kazuo Ishiguro’s nuanced fiction meets the stark realities of post‑2014 Indian journalism. Uncover how “Godi Media” turned from watchdog to lapdog, echoing the moral compromises of Ishiguro’s protagonists. We’ll draw parallels between restrained narrative silences and sensationalist headlines—are our media heroes or traitors? Don’t forget to follow for more deep dives!
M.A. Sem - 2 | Presentation
Presentation Season - 2
Paper - 107: The Twentieth Century Literature: From World War II to the End of the Century
Submitted Date: April 4, 2025
Paper Name: The Twentieth Century Literature: From World War II to the End of the Century
Topic: From Watchdog to Lapdog: Ishiguro’s Fiction and the Rise of “Godi Media” in Post-2014 Indian Journalism
[Please copy the link and paste it into any web browser to access the content.]
Video Link: https://youtu.be/kIEqwzhHJ54
For a more in-depth discussion of this presentation, please visit the full blog post at the following link: https://rajdeepbavaliya2.blogspot.com/2025/04/from-watchdog-to-lapdog-ishiguro-s-fiction-and-the-rise-of-godi-media-in-post-2014-indian-journalism.html
Please visit this blog to explore additional presentations from this season:
Hashtags:
#GodiMedia #Ishiguro #MediaEthics #WatchdogVsLapdog #IndianJournalism #PressFreedom #LiteraryCritique #AnArtistOfTheFloatingWorld #MediaCapture #KazuoIshiguro
Keyword Tags:
Godi Media, Ishiguro fiction, post-2014 Indian journalism, media capture, Kazuo Ishiguro analysis, watchdog to lapdog, press freedom India, media ethics, literature and media, An Artist of the Floating World
2 - OOP
- 1. S.Ducasse 1 QuickTime™ and aTIFF (Uncompressed) decompressorare needed to see this picture. Stéphane Ducasse [email protected] http://www.listic.univ-savoie.fr/~ducasse/ History and Concepts
- 2. S.Ducasse 2 Outline • History • Context • Run-Time Architecture • Concepts • "Making simple things very simple and complex things very possible." Alan Kay
- 3. S.Ducasse 3 Smalltalk: a State of Mind • A small and uniform language: • Syntax fits on one sheet of paper • A large set of reusable classes • Basic Data Structures, GUI classes, Database Access, Internet, Graphics • A set of powerful development tools • Browsers, GUI Builders, Inspectors, Change Management Tools, Crash Recovery Tools, Project Management Tools • A run-time environment based on virtual machine technology • Really Platform Independent • Team Working Environment (releasing, versioning, deploying).
- 4. S.Ducasse 4 Smalltalk - The Inspiration • Flex (Alan Kay, 1969) • Lisp (Interpreter, Blocks, Garbage Collection) • Turtle graphics (The Logo Project, Programming for Children) • Direct Manipulation Interfaces (Sketchpad,Alan Sutherland, 1960) • NLS, (Doug Engelbart, 1968),“the augmentation of human intellect” • Simula (Classes and Message Sending) – Description of real Phenomenons by means of a specification language -> modelling • Xerox PARC (Palo Alto Research Center) • DynaBook: a Laptop Computer for Children
- 6. S.Ducasse 6 Smalltalk on Alto III Alto: a Machine to Run Smalltalk
- 7. S.Ducasse 7 Precursor, Innovator &Visionary • First to be based on Graphics – Multi-Windowing Environment (Overlapping Windows) – Integrated Development Environment – -> Debugger, Compiler,Text Editor, Browser • With a pointing Device->Yes, a Mouse • Ideas were taken over – Apple Lisa, Mac – Microsoft Windows 1.0 • Virtual Machine -> Platform independent • Garbage Collector -> Time for some real thinking... • Just in Time Compilation • Everything was there, the complete Source Code
- 8. S.Ducasse 8 The History 1960 1970 1980 1990 FORTRAN Algol 60 COBOL PL/1 Simula 67 Smalltalk 72 Smalltalk 80 Objective C C C++ Ada Lisp Pascal Prolog Modula-2 Modula-3 Oberon ANSI C++ Self Eiffel Algol 68 Clu Java Ada 95 CLOS
- 9. S.Ducasse 9 The History (Internal) • 1972 - First Interpreter -> More Agents than Objects (every object can specify its own syntax) • 1976 - Redesign -> A Hierarchy of classes with a Unique Root, Fixed Syntax, Compact Byte Code, Contexts, Processes, Semaphores, Browsers, GUI Library. Projects: ThingLab,Visual Programming Environment Programming by Rehearsal. • 1978 - NoteTaker Project, Experimentation with 8086 Microprocessor with only 256 KB RAM.
- 10. S.Ducasse 10 The History (External) • 1980 - Smalltalk-80 (ASCII, cleaning primitives for portability, Metaclasses, Blocks as first-class Objects, MVC). Projects: Gallery Editor (mixing text, painting and animations) + Alternate Reality Kit (physics simulation) • 1981 - Books + 4 external virtual machines (Dec,Apple, HP and Tektronix) -> GC by generation scavenging • 1988 - Creation of Parc Place Systems • 1992 - ANSI Draft • 1995 - New Smalltalk implementations (MT, Dolphin, Squeak, Smalltalk/X, GNU Smalltalk) • 2000 - Fscript, GNU Smalltalk, SmallScript • 2002 - Smalltalk as OS: 128k ram
- 11. S.Ducasse 11 Smalltalk’s Concepts • Everything is an object (numbers, files, editors, compilers, points, tools, boolean). • Objects communicate only by message passing. • Each object is an instance of one class (which is also an object). • A class defines the structure and the behavior of its instances. • Each object possesses its own set of values. • Dynamic Typing. • Purely based on late binding.
- 12. S.Ducasse 12 Messages and Methods Message:What behavior to perform aWorkstation accept: aPacket aMonter eat: aCookie Method: How to carry out the behaviour accept: aPacket (aPacket isAddressedTo: self) ifTrue:[ Transcript show: 'A packet is accepted by the Workstation ', self name asString] ifFalse: [super accept: aPacket]
- 13. S.Ducasse 13 Objects and Classes • Every object is an instance of a class • A class specifies the structure and the behaviour of all its instances • Instances of a class share the same behavior and have a specific state • Classes are objects that create other instances • Metaclasses are classes that create classes as instances • Metaclasses describe class behaviour and state (subclasses, method dictionary, instance variables...)
- 14. S.Ducasse 14 Smalltalk Run-Time Architecture Virtual Machine + Image + Changes and Sources Image = bytecodes A bytethe vir IMAGE2IMAGE2StandShar IMAGE1.IMAGE1. All the objeat a momen One per us +
- 15. S.Ducasse 15 Smalltalk Run-Time Architecture • The byte-code is in fact translated into native code by a just-in-time compiler. • The source and the changes are not necessary for interpreting the byte-code, this is just for the development. Normally they are removed for deployment. • An application can be delivered as some byte-code files that will be executed with aVM.The development image is stripped to remove the unnecessary development components.
- 16. S.Ducasse 16 Summary Had a major impact: Java, Ruby, C# Simple and consistent model Everything is an object All computation is made by sending message Classes, Single inheritance, public methods, private attributes Uniform syntax Not an old language Still one of the most elegant, simple, uniform prue object-oriented language