3 - OOP - Squeak
•Download as PPT, PDF•
0 likes•800 views
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.
Report
Share
Report
Share
Recommended
3 - OOP - VisualWorks (a)
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)
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.
Stoop 436-strategy
The document discusses the strategy design pattern, which defines a family of algorithms, encapsulates each in a separate class, and defines the same interface so they can be interchangeable. The strategy pattern allows algorithms to vary independently from clients that use them by assigning responsibility for a task to various strategy classes. This improves flexibility by making algorithms easily replaceable at runtime and reduces complexity in client classes. The key participants are a strategy interface, concrete strategy classes that implement it, and a context class that maintains a reference to a strategy and delegates work to it.
14 - Exceptions
Exception handling in Smalltalk involves catching exceptions using an "on:do:" block. The document discusses the standardization of exceptions in 1996, the predefined exception classes like Error and Notification, and how to catch, signal, and handle exceptions in code. It also covers exception sets, the exception environment, and different ways exceptions can be handled or exited from including resume, return, retry, and resignalAs:.
Stoop 303-advanced blocks
The document discusses lexical scoping and returning values in blocks in Smalltalk. It explains that variables in blocks are bound in the context where the block is defined, not where it is evaluated. Continuation blocks can return values to the method that activated the home context. Returning from blocks requires care, as returning from within a block actually returns from the enclosing method. Examples demonstrate block evaluation, scoping, and using continuation blocks to return values or escape block evaluation.
5 - OOP - Smalltalk in a Nutshell (a)
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.
Stoop 433-chain
1) The chain of responsibility pattern avoids coupling the sender of a request to its receiver by allowing more than one object to handle the request. The request is passed along a chain of receiving objects until one of the objects handles it.
2) It reduces coupling between objects and simplifies connections by having each object in the chain only know about its successor instead of all possible receivers.
3) Responsibilities can be flexibly distributed among objects by adding or changing objects in the chain at runtime.
Stoop ed-lod
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.
Recommended
3 - OOP - VisualWorks (a)
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)
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.
Stoop 436-strategy
The document discusses the strategy design pattern, which defines a family of algorithms, encapsulates each in a separate class, and defines the same interface so they can be interchangeable. The strategy pattern allows algorithms to vary independently from clients that use them by assigning responsibility for a task to various strategy classes. This improves flexibility by making algorithms easily replaceable at runtime and reduces complexity in client classes. The key participants are a strategy interface, concrete strategy classes that implement it, and a context class that maintains a reference to a strategy and delegates work to it.
14 - Exceptions
Exception handling in Smalltalk involves catching exceptions using an "on:do:" block. The document discusses the standardization of exceptions in 1996, the predefined exception classes like Error and Notification, and how to catch, signal, and handle exceptions in code. It also covers exception sets, the exception environment, and different ways exceptions can be handled or exited from including resume, return, retry, and resignalAs:.
Stoop 303-advanced blocks
The document discusses lexical scoping and returning values in blocks in Smalltalk. It explains that variables in blocks are bound in the context where the block is defined, not where it is evaluated. Continuation blocks can return values to the method that activated the home context. Returning from blocks requires care, as returning from within a block actually returns from the enclosing method. Examples demonstrate block evaluation, scoping, and using continuation blocks to return values or escape block evaluation.
5 - OOP - Smalltalk in a Nutshell (a)
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.
Stoop 433-chain
1) The chain of responsibility pattern avoids coupling the sender of a request to its receiver by allowing more than one object to handle the request. The request is passed along a chain of receiving objects until one of the objects handles it.
2) It reduces coupling between objects and simplifies connections by having each object in the chain only know about its successor instead of all possible receivers.
3) Responsibilities can be flexibly distributed among objects by adding or changing objects in the chain at runtime.
Stoop ed-lod
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.
Dispatch
This document discusses implementing boolean logic and conditional logic using messages instead of primitive types or conditionals in an object-oriented programming language. It shows how true and false can be implemented as objects that understand messages like not, | (or), and ifTrue:ifFalse: by delegating to subclasses. This approach avoids conditionals and uses message dispatching instead, which can be optimized by the virtual machine. The key ideas are that messages act as a dispatcher, subclasses create the vocabulary, and conditionals should be avoided in favor of using objects and messages.
10 - OOP - Inheritance (a)
This document discusses inheritance and method lookup in Smalltalk. It explains that inheritance allows classes to reuse and extend existing behavior from their ancestors. Method lookup starts by searching the class of the receiver, then traversing up the inheritance hierarchy if not found. The keyword super sends a message starting the lookup in the superclass of the method's class rather than the receiver's class, allowing overridden methods to invoke the superclass implementation.
Stoop 439-decorator
This document describes the Decorator design pattern. The Decorator pattern allows behavior to be added to individual objects dynamically at runtime by wrapping them in decorator objects that contain the added behavior. This provides a flexible alternative to subclassing for extending functionality. Decorators work by maintaining a reference to a component object and conforming to the same interface as the component. Requests are forwarded to the component and decorators can perform additional actions before and after forwarding.
12 - Conditions and Loops
This document discusses core concepts in Smalltalk including conditionals, loops, collections, common object behavior, and copying objects. It covers boolean logic and conditional expressions, the collection hierarchy with 80+ classes including Array, OrderedCollection, Dictionary, and Set. Common methods for collections like do:, select:, collect: are also summarized, as well as printing, reading, copying and notifying objects in the programming environment.
Stoop 414-smalltalk elementsofdesign
This document discusses various elements of object-oriented design, including instance initialization, enforcing instance creation interfaces, instance and class methods/variables, class initialization, and other design patterns and principles. It provides examples and recommendations for properly initializing instances, creating robust creation interfaces, sharing state between classes and instances, and avoiding common anti-patterns. The document also includes a case study on the Scanner class in Smalltalk to illustrate some of these concepts.
Stoop 431-visitor
The document discusses the visitor design pattern. It provides an example of using a visitor to evaluate and print arithmetic expressions. The visitor pattern allows defining new operations on objects without changing the classes of the objects. The example shows creating expression objects, then using an evaluator visitor and printer visitor to evaluate and print the expressions. It discusses various aspects of implementing visitors such as controlling traversal, granularity of visitor methods, and implementation tricks.
02 basics
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.
4 - OOP - Taste of Smalltalk (Tamagoshi)
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.
Stoop 450-s unit
Unit testing involves writing small tests for individual units or classes of code to ensure specified behaviors are maintained. Tests should be written incrementally and even before code is written. When bugs are discovered, write tests to demonstrate the bug before fixing. Tests act as documentation and provide confidence when refactoring code. Common unit testing frameworks like SUnit and JUnit provide tools for writing, running, and collecting test results. Tests should be repeatable, require no human intervention, and change less often than the code being tested.
3 - OOP - Runtime
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
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.
05 seaside canvas
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.
6 - OOP - LAN Example
This document discusses simulating a local area network (LAN) using objects. It describes three main kinds of objects: Nodes, Packets, and a NetworkManager. Nodes represent devices connected to the LAN like workstations and printers. Packets represent information that flows between Nodes. The NetworkManager manages how Nodes are connected. It provides examples of creating these objects, transmitting a Packet between Nodes, and defining Classes and Methods in Smalltalk.
Pharo Hands-On: 04 image-runtime
This document discusses Pharo's runtime environment and development process. It describes how Pharo uses a virtual machine and bytecode to run code, stores source code, binaries, and changes in files, and keeps images and changes in sync. The development process involves defining packages, dependencies, saving configurations, and continuous integration to automatically load and verify code.
Maya Pipeline Code Samples
The document describes several animation and visual effects production tools: Harmonica, an end-to-end production server; Pipeline Toolbox, a tool for navigating assets/shots and versioning content; Melodica, a port of Pipeline Toolbox to PyQt; and Sequence Shooter, a Python tool for Maya to help layout artists navigate shots. It provides details on the purpose and technical implementation of each tool.
Modern microcontroller (mcu) application development with qt
This document discusses Qt for MCUs and its value proposition for modern microcontroller application development. Qt for MCUs allows for a designer-friendly workflow with UI specification, product implementation, and deployment testing. It features a modern GUI toolkit, animation support, internationalization, examples, and optimization for embedded targets. The document demonstrates migrating a demo to Qt for MCUs 2.0, optimizing resources, and managing hardware from a QML application.
Technical Documentation_Embedded_Image_DSP_Projects
This document provides an overview of image processing algorithms for real-time embedded systems. It discusses objectives like image enhancement, restoration, feature extraction and compression. Technologies applied include the TMS320C6713 DSP, Code Composer Studio, MATLAB and OpenCV. Image enhancement algorithms covered are contrast stretching, window-level slicing, and histogram equalization. Image restoration techniques include low pass, high pass and rank order filtering. Feature extraction methods include edge detection and image segmentation. Wavelet-based techniques are also discussed for edge detection and denoising. Implementation challenges for real-time embedded systems are addressed.
Animation's Life Cycle And Its Application
This is my first presentation in the University in Computer Science Programme which went really well.So I thought to share it with someone out there, if it could be helpful to anyone.
CI/CD Pipeline with Docker
Basic Idea
Develop a build system that leverages Docker for implementing continuous integration/deployment(CI/CD) pipeline. A git commit must kick off packaging a Docker Image and provisioning it in a VM.
A git based commit should be used for starting of a build for a docker image which would then be run and provisioned in a Virtual Machine. After every commit a series of test cases is then run on the code to ensure the correctness of the code. After all the test-cases pass, the image gets updated on docker-hub registry, and a VM gets provisioned which can then run the software directly (after pulling the image from the docker-hub).
This entire process ensures that the most recent and updated version of the code is available to the person who is using the software and this speeds up the overall process by at least 2-3 folds.
Evolving Infrastructure
Choosing & building the appropriate infrastructure to run your applications in production can be a daunting task. Typically we revisit previous choices as we approach different scales. In this talk we'll cover the two architectures we've been through at Workday so far and speak about our third major architectural change as we ramp up to larger numbers of servers and users. Topics will include: deployment, configuration management, automation tools, build & test pipelines, immutable infrastructure.
Docker introduction & benefits
Docker allows for easy deployment and management of applications by wrapping them in containers. It provides benefits like running multiple isolated environments on a single server, easily moving applications between environments, and ensuring consistency across environments. The document discusses using Docker for development, production, and monitoring containers, and outlines specific benefits like reducing deployment time from days to minutes, optimizing hardware usage, reducing transfer sizes, and enhancing productivity. Future plans mentioned include using Kubernetes for container orchestration.
More Related Content
Viewers also liked
Dispatch
This document discusses implementing boolean logic and conditional logic using messages instead of primitive types or conditionals in an object-oriented programming language. It shows how true and false can be implemented as objects that understand messages like not, | (or), and ifTrue:ifFalse: by delegating to subclasses. This approach avoids conditionals and uses message dispatching instead, which can be optimized by the virtual machine. The key ideas are that messages act as a dispatcher, subclasses create the vocabulary, and conditionals should be avoided in favor of using objects and messages.
10 - OOP - Inheritance (a)
This document discusses inheritance and method lookup in Smalltalk. It explains that inheritance allows classes to reuse and extend existing behavior from their ancestors. Method lookup starts by searching the class of the receiver, then traversing up the inheritance hierarchy if not found. The keyword super sends a message starting the lookup in the superclass of the method's class rather than the receiver's class, allowing overridden methods to invoke the superclass implementation.
Stoop 439-decorator
This document describes the Decorator design pattern. The Decorator pattern allows behavior to be added to individual objects dynamically at runtime by wrapping them in decorator objects that contain the added behavior. This provides a flexible alternative to subclassing for extending functionality. Decorators work by maintaining a reference to a component object and conforming to the same interface as the component. Requests are forwarded to the component and decorators can perform additional actions before and after forwarding.
12 - Conditions and Loops
This document discusses core concepts in Smalltalk including conditionals, loops, collections, common object behavior, and copying objects. It covers boolean logic and conditional expressions, the collection hierarchy with 80+ classes including Array, OrderedCollection, Dictionary, and Set. Common methods for collections like do:, select:, collect: are also summarized, as well as printing, reading, copying and notifying objects in the programming environment.
Stoop 414-smalltalk elementsofdesign
This document discusses various elements of object-oriented design, including instance initialization, enforcing instance creation interfaces, instance and class methods/variables, class initialization, and other design patterns and principles. It provides examples and recommendations for properly initializing instances, creating robust creation interfaces, sharing state between classes and instances, and avoiding common anti-patterns. The document also includes a case study on the Scanner class in Smalltalk to illustrate some of these concepts.
Stoop 431-visitor
The document discusses the visitor design pattern. It provides an example of using a visitor to evaluate and print arithmetic expressions. The visitor pattern allows defining new operations on objects without changing the classes of the objects. The example shows creating expression objects, then using an evaluator visitor and printer visitor to evaluate and print the expressions. It discusses various aspects of implementing visitors such as controlling traversal, granularity of visitor methods, and implementation tricks.
02 basics
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.
4 - OOP - Taste of Smalltalk (Tamagoshi)
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.
Stoop 450-s unit
Unit testing involves writing small tests for individual units or classes of code to ensure specified behaviors are maintained. Tests should be written incrementally and even before code is written. When bugs are discovered, write tests to demonstrate the bug before fixing. Tests act as documentation and provide confidence when refactoring code. Common unit testing frameworks like SUnit and JUnit provide tools for writing, running, and collecting test results. Tests should be repeatable, require no human intervention, and change less often than the code being tested.
3 - OOP - Runtime
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
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.
05 seaside canvas
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.
6 - OOP - LAN Example
This document discusses simulating a local area network (LAN) using objects. It describes three main kinds of objects: Nodes, Packets, and a NetworkManager. Nodes represent devices connected to the LAN like workstations and printers. Packets represent information that flows between Nodes. The NetworkManager manages how Nodes are connected. It provides examples of creating these objects, transmitting a Packet between Nodes, and defining Classes and Methods in Smalltalk.
Viewers also liked (14)
Similar to 3 - OOP - Squeak
Pharo Hands-On: 04 image-runtime
This document discusses Pharo's runtime environment and development process. It describes how Pharo uses a virtual machine and bytecode to run code, stores source code, binaries, and changes in files, and keeps images and changes in sync. The development process involves defining packages, dependencies, saving configurations, and continuous integration to automatically load and verify code.
Maya Pipeline Code Samples
The document describes several animation and visual effects production tools: Harmonica, an end-to-end production server; Pipeline Toolbox, a tool for navigating assets/shots and versioning content; Melodica, a port of Pipeline Toolbox to PyQt; and Sequence Shooter, a Python tool for Maya to help layout artists navigate shots. It provides details on the purpose and technical implementation of each tool.
Modern microcontroller (mcu) application development with qt
This document discusses Qt for MCUs and its value proposition for modern microcontroller application development. Qt for MCUs allows for a designer-friendly workflow with UI specification, product implementation, and deployment testing. It features a modern GUI toolkit, animation support, internationalization, examples, and optimization for embedded targets. The document demonstrates migrating a demo to Qt for MCUs 2.0, optimizing resources, and managing hardware from a QML application.
Technical Documentation_Embedded_Image_DSP_Projects
This document provides an overview of image processing algorithms for real-time embedded systems. It discusses objectives like image enhancement, restoration, feature extraction and compression. Technologies applied include the TMS320C6713 DSP, Code Composer Studio, MATLAB and OpenCV. Image enhancement algorithms covered are contrast stretching, window-level slicing, and histogram equalization. Image restoration techniques include low pass, high pass and rank order filtering. Feature extraction methods include edge detection and image segmentation. Wavelet-based techniques are also discussed for edge detection and denoising. Implementation challenges for real-time embedded systems are addressed.
Animation's Life Cycle And Its Application
This is my first presentation in the University in Computer Science Programme which went really well.So I thought to share it with someone out there, if it could be helpful to anyone.
CI/CD Pipeline with Docker
Basic Idea
Develop a build system that leverages Docker for implementing continuous integration/deployment(CI/CD) pipeline. A git commit must kick off packaging a Docker Image and provisioning it in a VM.
A git based commit should be used for starting of a build for a docker image which would then be run and provisioned in a Virtual Machine. After every commit a series of test cases is then run on the code to ensure the correctness of the code. After all the test-cases pass, the image gets updated on docker-hub registry, and a VM gets provisioned which can then run the software directly (after pulling the image from the docker-hub).
This entire process ensures that the most recent and updated version of the code is available to the person who is using the software and this speeds up the overall process by at least 2-3 folds.
Evolving Infrastructure
Choosing & building the appropriate infrastructure to run your applications in production can be a daunting task. Typically we revisit previous choices as we approach different scales. In this talk we'll cover the two architectures we've been through at Workday so far and speak about our third major architectural change as we ramp up to larger numbers of servers and users. Topics will include: deployment, configuration management, automation tools, build & test pipelines, immutable infrastructure.
Docker introduction & benefits
Docker allows for easy deployment and management of applications by wrapping them in containers. It provides benefits like running multiple isolated environments on a single server, easily moving applications between environments, and ensuring consistency across environments. The document discusses using Docker for development, production, and monitoring containers, and outlines specific benefits like reducing deployment time from days to minutes, optimizing hardware usage, reducing transfer sizes, and enhancing productivity. Future plans mentioned include using Kubernetes for container orchestration.
Using Docker in CI process
This presentation covers a basic idea of how we could apply Docker while building a CI / CD environment
[FOSDEM 2020] Lazy distribution of container images
https://fosdem.org/2020/schedule/event/containers_lazy_image_distribution/
The biggest problem of the OCI Image Spec is that a container cannot be started until all the tarball layers are downloaded, even though more than 90% of the tarball contents are often unneeded for the actual workload.
This session will show state-of-the-art alternative image formats, which allow runtime implementations to start a container without waiting for all its image contents to be locally available.
Especially, this session will put focus on CRFS/stargz and its implementation status in containerd (https://github.com/containerd/containerd/issues/3731). The plan for BuildKit integration will be shown as well.
DockerCon SF 2015: Maintaining the official node.js docker image
This document discusses maintaining the official Node.js Docker image. It covers how Joyent took over an existing official image, the workflow for updating images, testing images, using tags and variants, keeping images small, monitoring user feedback, and future plans regarding the merging of Node.js and io.js. It provides recommendations for those starting from scratch on official images, such as using an official base image, including tests, and considering image size versus usefulness.
CI/CD 101
The document discusses continuous integration (CI) and continuous delivery (CD), which are software engineering practices. It recommends ways to implement CI/CD, including creating a single source of truth repository, enabling on-demand environment creation, making infrastructure easier to rebuild than repair, modifying the definition of done, and amplifying feedback through automated testing and logging.
The overview of lazypull with containerd Remote Snapshotter & Stargz Snapshotter
The overview of containerd Remote Snapshotter & Stargz Snapshotter.
https://github.com/containerd/stargz-snapshotter
How Postman adopted Docker
This deck is the story around how Postman was able to scale to serve 10+ million requests per hour in one year from startup and how docker became an integral part of it's frugal operations
OpenEmbedded & BitBake - Denx
OpenEmbedded and BitBake are open source tools used to build Linux distributions for embedded systems. BitBake controls the build process by executing tasks based on recipes. It collects build descriptions from recipes and dependencies to compile packages in the proper order. OpenEmbedded contains metadata like build classes, machine configurations, and recipes that define how to cross-compile, package, and install software for complete embedded Linux distributions.
DockerCon SF 2015: Maintaining the Official Node.js Docker Image
- Joyent maintains the official Node.js Docker image, taking it over from its original creators. They aim to follow best practices like using an official base image, offering multiple tagged versions, and adding tests to ensure images build properly.
- Tags and variants like slim or different base OSes allow users flexibility. Proper documentation is important for understanding the different options.
- Automated testing, like with Serverspec, helps validate images before release. User feedback, like via GitHub issues, also helps improve the images.
- The Node.js and io.js projects plan to merge, which may impact the Docker images going forward as they are maintained by a working group under the Node.js foundation.
The caQtDM powerpoint (ICALEPCS 2013)
This document summarizes a new display manager called caQtDM, which was developed to replace MEDM at the Paul Scherrer Institut. caQtDM is based on Qt rather than MOTIF and X11 like MEDM. It reproduces MEDM's functionality and can run on Windows as well as platforms where Qt is supported. MEDM display files were converted to the new XML format and edited in Qt Designer. caQtDM integrates well with EPICS and other control systems. It has a library class that handles data acquisition and display separately from the display definitions.
The caQtDm paper (ICALEPCS 2013)
This document discusses CAQTDM, a new display manager for EPICS control systems based on Qt. It was developed at Paul Scherrer Institut to replace their aging MEDM display manager. CAQTDM reproduces MEDM's functionality and can display EPICS and other control system data. It uses the Qt framework for cross-platform support. Control displays are designed using the Qt Designer and displayed using the CAQTDM application. The architecture separates display design from data acquisition, allowing it to interface with multiple control systems like EPICS and ACS.
Code Factory avec GitLab CI et Rancher
Rancher et Kubernetes sont le moteur de la majorité des applications modernes en production. Mais la chaine d'automatisation permettant de livrer du code l'esprit léger commence bien plus en amont grace à un outillage Open Source.
Au programme :
- Commit Code : Avec Gitlab et les outils de collaboration
- Build Image : Toujours plus de fiabilité avec les images SLE Base Container Image
- Store in Registry : Archivage et scan de vulnérabilité avec Harbor
- Test & Go : Livraison en continue avec le mode GitOps et Rancher Fleet
Alexander Kutsan: “C++ compilation boost”
The document discusses ways to improve long C++ compilation times. It describes how C++ code is traditionally compiled into individual object files and then linked into an executable. This process can be lengthy. The document proposes parallelizing compilation by splitting source files among multiple compiler processes. It also suggests using caching and distributed compilation techniques like CCache and distcc to further speed up builds. Statistics are presented showing how these approaches can significantly reduce compilation times for large C++ codebases. Overall, the document explores common issues that slow C++ compilation and different strategies for addressing this problem.
Similar to 3 - OOP - Squeak (20)
Modern microcontroller (mcu) application development with qt
Modern microcontroller (mcu) application development with qt
Technical Documentation_Embedded_Image_DSP_Projects
Technical Documentation_Embedded_Image_DSP_Projects
[FOSDEM 2020] Lazy distribution of container images
[FOSDEM 2020] Lazy distribution of container images
DockerCon SF 2015: Maintaining the official node.js docker image
DockerCon SF 2015: Maintaining the official node.js docker image
The overview of lazypull with containerd Remote Snapshotter & Stargz Snapshotter
The overview of lazypull with containerd Remote Snapshotter & Stargz Snapshotter
DockerCon SF 2015: Maintaining the Official Node.js Docker Image
DockerCon SF 2015: Maintaining the Official Node.js Docker Image
More from The World of Smalltalk
99 questions
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.
13 traits
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.
12 virtualmachine
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
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
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
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
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
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
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
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.
04 idioms
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.
03 standardclasses
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.
01 intro
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.
Stoop sed-smells
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
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
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
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
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
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
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.
More from The World of Smalltalk (20)
Recently uploaded
How to Setup Warehouse & Location in Odoo 17 Inventory
In this slide, we'll explore how to set up warehouses and locations in Odoo 17 Inventory. This will help us manage our stock effectively, track inventory levels, and streamline warehouse operations.
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is special for master students (MIBS & MIFB) in UUM. Also useful for readers who are interested in the topic of contemporary Islamic banking.
What is Digital Literacy? A guest blog from Andy McLaughlin, University of Ab...
What is Digital Literacy? A guest blog from Andy McLaughlin, University of Aberdeen
PCOS corelations and management through Ayurveda.
This presentation includes basic of PCOS their pathology and treatment and also Ayurveda correlation of PCOS and Ayurvedic line of treatment mentioned in classics.
BÀI TẬP BỔ TRỢ TIẾNG ANH LỚP 9 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2024-2025 - ...
BÀI TẬP BỔ TRỢ TIẾNG ANH LỚP 9 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2024-2025 - ...Nguyen Thanh Tu Collection
https://app.box.com/s/tacvl9ekroe9hqupdnjruiypvm9rdaneHow to Fix the Import Error in the Odoo 17
An import error occurs when a program fails to import a module or library, disrupting its execution. In languages like Python, this issue arises when the specified module cannot be found or accessed, hindering the program's functionality. Resolving import errors is crucial for maintaining smooth software operation and uninterrupted development processes.
Wound healing PPT
This document provides an overview of wound healing, its functions, stages, mechanisms, factors affecting it, and complications.
A wound is a break in the integrity of the skin or tissues, which may be associated with disruption of the structure and function.
Healing is the body’s response to injury in an attempt to restore normal structure and functions.
Healing can occur in two ways: Regeneration and Repair
There are 4 phases of wound healing: hemostasis, inflammation, proliferation, and remodeling. This document also describes the mechanism of wound healing. Factors that affect healing include infection, uncontrolled diabetes, poor nutrition, age, anemia, the presence of foreign bodies, etc.
Complications of wound healing like infection, hyperpigmentation of scar, contractures, and keloid formation.
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcHow to deliver Powerpoint Presentations.pptx
"How to make and deliver dynamic presentations by making it more interactive to captivate your audience attention"
Reimagining Your Library Space: How to Increase the Vibes in Your Library No ...
Librarians are leading the way in creating future-ready citizens – now we need to update our spaces to match. In this session, attendees will get inspiration for transforming their library spaces. You’ll learn how to survey students and patrons, create a focus group, and use design thinking to brainstorm ideas for your space. We’ll discuss budget friendly ways to change your space as well as how to find funding. No matter where you’re at, you’ll find ideas for reimagining your space in this session.
ANATOMY AND BIOMECHANICS OF HIP JOINT.pdf
it describes the bony anatomy including the femoral head , acetabulum, labrum . also discusses the capsule , ligaments . muscle that act on the hip joint and the range of motion are outlined. factors affecting hip joint stability and weight transmission through the joint are summarized.
Chapter wise All Notes of First year Basic Civil Engineering.pptx
Chapter wise All Notes of First year Basic Civil Engineering
Syllabus
Chapter-1
Introduction to objective, scope and outcome the subject
Chapter 2
Introduction: Scope and Specialization of Civil Engineering, Role of civil Engineer in Society, Impact of infrastructural development on economy of country.
Chapter 3
Surveying: Object Principles & Types of Surveying; Site Plans, Plans & Maps; Scales & Unit of different Measurements.
Linear Measurements: Instruments used. Linear Measurement by Tape, Ranging out Survey Lines and overcoming Obstructions; Measurements on sloping ground; Tape corrections, conventional symbols. Angular Measurements: Instruments used; Introduction to Compass Surveying, Bearings and Longitude & Latitude of a Line, Introduction to total station.
Levelling: Instrument used Object of levelling, Methods of levelling in brief, and Contour maps.
Chapter 4
Buildings: Selection of site for Buildings, Layout of Building Plan, Types of buildings, Plinth area, carpet area, floor space index, Introduction to building byelaws, concept of sun light & ventilation. Components of Buildings & their functions, Basic concept of R.C.C., Introduction to types of foundation
Chapter 5
Transportation: Introduction to Transportation Engineering; Traffic and Road Safety: Types and Characteristics of Various Modes of Transportation; Various Road Traffic Signs, Causes of Accidents and Road Safety Measures.
Chapter 6
Environmental Engineering: Environmental Pollution, Environmental Acts and Regulations, Functional Concepts of Ecology, Basics of Species, Biodiversity, Ecosystem, Hydrological Cycle; Chemical Cycles: Carbon, Nitrogen & Phosphorus; Energy Flow in Ecosystems.
Water Pollution: Water Quality standards, Introduction to Treatment & Disposal of Waste Water. Reuse and Saving of Water, Rain Water Harvesting. Solid Waste Management: Classification of Solid Waste, Collection, Transportation and Disposal of Solid. Recycling of Solid Waste: Energy Recovery, Sanitary Landfill, On-Site Sanitation. Air & Noise Pollution: Primary and Secondary air pollutants, Harmful effects of Air Pollution, Control of Air Pollution. . Noise Pollution Harmful Effects of noise pollution, control of noise pollution, Global warming & Climate Change, Ozone depletion, Greenhouse effect
Text Books:
1. Palancharmy, Basic Civil Engineering, McGraw Hill publishers.
2. Satheesh Gopi, Basic Civil Engineering, Pearson Publishers.
3. Ketki Rangwala Dalal, Essentials of Civil Engineering, Charotar Publishing House.
4. BCP, Surveying volume 1
বাংলাদেশ অর্থনৈতিক সমীক্ষা (Economic Review) ২০২৪ UJS App.pdf
বাংলাদেশের অর্থনৈতিক সমীক্ষা ২০২৪ [Bangladesh Economic Review 2024 Bangla.pdf] কম্পিউটার , ট্যাব ও স্মার্ট ফোন ভার্সন সহ সম্পূর্ণ বাংলা ই-বুক বা pdf বই " সুচিপত্র ...বুকমার্ক মেনু 🔖 ও হাইপার লিংক মেনু 📝👆 যুক্ত ..
আমাদের সবার জন্য খুব খুব গুরুত্বপূর্ণ একটি বই ..বিসিএস, ব্যাংক, ইউনিভার্সিটি ভর্তি ও যে কোন প্রতিযোগিতা মূলক পরীক্ষার জন্য এর খুব ইম্পরট্যান্ট একটি বিষয় ...তাছাড়া বাংলাদেশের সাম্প্রতিক যে কোন ডাটা বা তথ্য এই বইতে পাবেন ...
তাই একজন নাগরিক হিসাবে এই তথ্য গুলো আপনার জানা প্রয়োজন ...।
বিসিএস ও ব্যাংক এর লিখিত পরীক্ষা ...+এছাড়া মাধ্যমিক ও উচ্চমাধ্যমিকের স্টুডেন্টদের জন্য অনেক কাজে আসবে ...
Recently uploaded (20)
How to Setup Warehouse & Location in Odoo 17 Inventory
How to Setup Warehouse & Location in Odoo 17 Inventory
Film vocab for eal 3 students: Australia the movie
Film vocab for eal 3 students: Australia the movie
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
Chapter 4 - Islamic Financial Institutions in Malaysia.pptx
What is Digital Literacy? A guest blog from Andy McLaughlin, University of Ab...
What is Digital Literacy? A guest blog from Andy McLaughlin, University of Ab...
Digital Artefact 1 - Tiny Home Environmental Design
Digital Artefact 1 - Tiny Home Environmental Design
BÀI TẬP BỔ TRỢ TIẾNG ANH LỚP 9 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2024-2025 - ...
BÀI TẬP BỔ TRỢ TIẾNG ANH LỚP 9 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2024-2025 - ...
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
NEWSPAPERS - QUESTION 1 - REVISION POWERPOINT.pptx
NEWSPAPERS - QUESTION 1 - REVISION POWERPOINT.pptx
Reimagining Your Library Space: How to Increase the Vibes in Your Library No ...
Reimagining Your Library Space: How to Increase the Vibes in Your Library No ...
Liberal Approach to the Study of Indian Politics.pdf
Liberal Approach to the Study of Indian Politics.pdf
Chapter wise All Notes of First year Basic Civil Engineering.pptx
Chapter wise All Notes of First year Basic Civil Engineering.pptx
বাংলাদেশ অর্থনৈতিক সমীক্ষা (Economic Review) ২০২৪ UJS App.pdf
বাংলাদেশ অর্থনৈতিক সমীক্ষা (Economic Review) ২০২৪ UJS App.pdf
3 - OOP - Squeak
- 1. S.Ducasse 1 QuickTime™ and aTIFF (Uncompressed) decompressorare needed to see this picture. Stéphane Ducasse Stephane.Ducasse@univ-savoie.fr http://www.listic.univ-savoie.fr/~ducasse/ The Squeak Environment
- 2. S.Ducasse 2 License: CC-Attribution-ShareAlike 2.0 http://creativecommons.org/licenses/by-sa/2.0/
- 3. S.Ducasse 3 Smalltalk Run-Time Architecture • Virtual Machine + Image + Changes and Sources • Image = bytecodes • Sources and changes = code (text) A bytethe vir IMAGE2IMAGE2StandShar IMAGE1.IMAGE1. All the objeat a momen One per us +
- 4. S.Ducasse 4 Runtime 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.
- 5. S.Ducasse 5 Mouse Semantics SelectOperatWinRed BlueYellow
- 6. S.Ducasse 6 World Menu and Open Menu
- 7. S.Ducasse 7 Browsing a class
- 9. S.Ducasse 9 Inspector • To look inside objects • Violates encapsulation!!! • Monster new inspect
- 10. S.Ducasse 10 Direct Manipulation • Bring the halo • Experiment
- 14. S.Ducasse 14 Message Names Finder
- 15. S.Ducasse 15
- 16. S.Ducasse 16 Methods in ChangeSets +Versions
- 19. S.Ducasse 19 Transcript is Sloooooooooooow 19
- 20. S.Ducasse 20 Squeak Map Package Loader
- 22. S.Ducasse 22 Monticello Change Browser
- 25. S.Ducasse 25 Changes Menu…Recently logged files • Everything you do is recorded
- 26. S.Ducasse 26 ChangeSorter: to sort your changes
- 27. S.Ducasse 27 Cool Packages to Load Shout Refactoring Browser eCompletion
- 28. S.Ducasse 28 Change your Mind Everything you do is recorded !! So try and learn how to recover your code You are smart so Experiment, Learn for you, browse, educate your taste (not all Squeak code is good) Be aggressive, ***all*** the code is there