Smalltalk Questions and Answers for Viva

Answer-1: Smalltalk is an object-oriented, dynamically typed programming language known for its simplicity and reflective programming environment.

Answer-2: Smalltalk was developed at Xerox PARC in the 1970s by Alan Kay, Dan Ingalls, and their team.

Answer-3: Smalltalk is used for educational purposes, prototyping, and developing highly interactive applications.

Answer-4: Key features include pure object orientation, dynamic typing, a reflective environment, and a consistent message-passing model.

Answer-5: Smalltalk uses a minimal and highly readable syntax based on sending messages to objects.

Answer-6: In Smalltalk, everything is an object, including numbers, booleans, and even classes.

Answer-7: The basic construct of Smalltalk is sending messages to objects.

Answer-8: Classes are created using the Object subclass: ClassName syntax, e.g., Object subclass: MyClass.

Answer-9: The Transcript object is used for printing output and debugging.

Answer-10: Smalltalk supports single inheritance where a class can inherit from only one parent class.

Answer-11: Messages are the way objects communicate by invoking methods.

Answer-12: Variables are declared using `

Answer-13: A workspace is an interactive area in the Smalltalk environment where developers can write and evaluate code snippets.

Answer-14: Blocks are anonymous functions or closures, enclosed in square brackets, e.g., `[ :x

Answer-15: Smalltalk uses message passing for conditionals, e.g., condition ifTrue: [doSomething] ifFalse: [doSomethingElse].

Answer-16: Loops are implemented using messages like to:do:, e.g., `1 to: 10 do: [:i

Answer-17: Smalltalk uses garbage collection for automatic memory management.

Answer-18: nil represents the absence of a value, similar to null in other languages.

Answer-19: Selectors are the names of messages that are sent to objects, e.g., +, do:, ifTrue:.

Answer-20: Collections are objects that store groups of elements, such as Array, Set, and Dictionary.

Answer-21: Methods are defined in a class's method dictionary, e.g., MyClass >> methodName.

Answer-22: == checks for object identity, while = checks for equality of values.

Answer-23: A metaclass is a class of a class, defining the behavior and properties of its instances (the classes themselves).

Answer-24: Exceptions are handled using on:do: blocks, e.g., `[code] on: Exception do: [:ex

Answer-25: Use Transcript show: 'message'; cr.

Answer-26: self refers to the current instance of the class.

Answer-27: Polymorphism allows objects of different classes to respond to the same message in different ways.

Answer-28: A singleton can be implemented by overriding the new method to ensure only one instance is created.

Answer-29: super is used to invoke a method of the superclass.

Answer-30: The image is a snapshot of the entire Smalltalk environment, including all objects, classes, and workspace contents.

Answer-31: Comments are written using double quotes, e.g., "This is a comment".

Answer-32: Dynamic typing allows flexibility by determining types at runtime rather than compile time.

Answer-33: File I/O is handled using the FileStream class.

Answer-34: Reflection allows a program to inspect and modify its own structure and behavior at runtime.

Answer-35: Use the new message, e.g., MyClass new.

Answer-36: Protocols are categories of methods that organize a class's methods into groups for better readability.

Answer-37: The Smalltalk object represents the system dictionary, containing all classes and global variables.

Answer-38: class defines a new class, while subclass defines a new class inheriting from an existing one.

Answer-39: Method overriding occurs when a subclass redefines a method from its superclass.

Answer-40: Smalltalk does not support multiple inheritance but uses single inheritance and composition.

Answer-41: Debugging is done using the integrated debugger in the Smalltalk environment, often triggered by unhandled exceptions.

Answer-42: Advantages include simplicity, readability, powerful IDE, and pure object orientation.

Answer-43: Class variables are shared among all instances of a class, while instance variables are specific to each object.

Answer-44: Testing is performed using frameworks like SUnit, a precursor to JUnit.

Answer-45: Messages are sent using the receiver message syntax, e.g., 5 + 3.

Answer-46: Lazy evaluation delays computation until the result is needed, often implemented using blocks.

Answer-47: Object is the root of the class hierarchy and the superclass of all classes.

Answer-48: Encapsulation is achieved by controlling access to an object's state through messages and hiding internal implementation details.

Answer-49: Different objects can respond to the same message, e.g., both String and Array respond to size.

Answer-50: Disadvantages include a steep learning curve, limited mainstream adoption, and fewer modern libraries compared to other languages.