• Newspeak is a direct descendant of Smalltalk.
• Unlike Smalltalk Newspeak has an intentional, syntactic representation of classes; this is crucial in supporting nested classes, which are not present in Smalltalk.
• Smalltalk has a global namespace and abundant static state. Most fundamentally, Smalltalk distinguishes between method invocation and variable access it is not a purely message based language.
• These differences lead to a different semantics of method lookup (cont).

(see http://gbracha.blogspot.ca/2007/05/message-based-programming.html)

• Smalltalk terminology refers to method invocations as message sends. Message passing is often associated with asynchrony, but it doesn't have to be. Smalltalk message sends are synchronous. As such, they seem indistinguishable from virtual method invocations. However, the terminology matters.
• Insisting that objects communicate exclusively via message sends rules out aberrations such as static methods, non-virtual methods, constructors and public fields. More than that: It means that one cannot access another object's internals - we have to send the object a message. So when we say that an object encapsulates its data, encapsulation can't be interpreted as just bundling - it means data abstraction. Two objects that respond the same way to all messages are indistinguishable, regardless of their implementation details.
  • We can nevertheless ask: is Smalltalk a message based programming language? I think not. I would take message-based programming to have an even stronger requirement: all computation is done via message passing. That includes the computation done within a single object as well. Whereas Smalltalk objects can access variables and assign them, message based programming would require that an object use messages internally as well. This is exactly what happens in Self, as I discussed in an earlier post about representation independent code.

• There are no assignment operator in Newspeak
• ::= (initializer only), vs = (2 roles, function and class declaration, equality) vs :: vs == (identity) - these were already discused in a section above.
• More differences from Smalltalk:
  • Refer to slides 11-20 (accent: slide 15) from ⁸ and discuss
  • No Global variables, no assignment, no static (global) state.
  • The only runtime operation is message send. In the example on slide 15:
    • t:: looks like a variable but is a setter, automatically generated (no assignment, all slot access in Newspeak is replaced with a message send)
    • Array must be implicitly passed to the application (no static)
  • Class categories are a Smalltalk legacy that will likely be dropped in the future
  • Packages are likely to be removed as well.

• There is a document http://bracha.org/Smalltalk2NS2.pdf describing how to convert Smalltalk code to Squeak.
• I do not have enough Newspeak to prove this on any sufficiently sized program, but, according to The Ministry of Truth in ², code converted from Smalltalk to Newspeak:
  • The converted code is better than the original.
  • It becomes clear:
    • what the code's external dependencies are
    • what the module boundaries should be
    • who is responsible for initialization
  • There is no longer any static state.
  • Easier to tie libraries together (or tear them apart),
  • Easier libraries independent testing
  • Smalltalkers can migrate to Newspeak relatively easily.

I will do my best to show some of these points on an example in the modularity section.

1. Some syntax is evolving. I think I saw on the web some examples using a := b, replace that with a:: b (setter send). Note the :: must not be separated by space.
2. See the notes on ::= vs = vs :: vs =() in this presentation in syntax notes above

There is an important improvement in Newspeak regarding constructors.

In his Room 101 blog, Gilad Bracha describes:

• Weaknesses of and deficiencies of constructors in languages such as Java.
• Weaknesses of object creation in Smalltalk

Newspeak's constructors (and also Dart to a degree) resolve the discussed constructor issues. - Most comments here are again inspired by and used from Gilad Bracha's Room 101 blog

• Constructors Considered Harmful ¹⁰
• Object Initialization and Construction Revisited ¹¹

Let us take a look at this pseudo-Java code:

class Thing {
  // implicit extends Object, 
  // constructor can be implicit
  Thing() {
  }
}

// class declaration
class Car extends Thing {
  // constructor
  Car(String color) {
    super(); // implicit
    this.color = color.
  }
  int countWheels() {
    return 4;
  }
}

// client code uses constructor this way:
Car c = new Car('blue'); // This is not Object Oriented - no receiver

// client code sends a message this way:
int wheels = c.countWheels(); // This is Object Oriented: receiver.message()

Here we see a few issues:

• is new a method? what object is it called on?
• is Car('blue') a method invocation? what object is it called on?

Answer:

• new is not a message to any object
• Car('blue') is not a message to any object either
• Because there is no receiver
• Rather the "constructor construct" new Car('blue') is wired in as a special case, in a way that does not match the message send OO pattern.
• So when we say Java is lacking because not everything is an object, it is true, but the problem goes deeper - non uniformity and non-object orientedness / receiver.message() syntax of some core constructs.

In Java (and similar languages), there are constructor issues like:

• Constructor cannot be overridden like instance methods (no target object, so no dynamic dispatch).
• Constructor new Car('blue') cannot return an instance of another object or cached or proxy object.
• All constructors need to call another constructor, or a superclass constructor etc.
• Mixins are hard to implement in a language with constructors.
• Constructors are a major cause of need of dependency injection.
• Constructors are a major issue for testability: (new Car('blue') cannot return a mock of a car).

• Use a static method makeCar('blue') on the same class on another class (aka "factory method"):

  CarFactory.makeCar(String color) { can return instance of Car, it's subclass, a proxy or something else }
  

  • But static methods in Java has similar problems:
    • Static method has no runtime target object - are wired at compile time => no abstraction via interface, no dynamic binding or overriding
    • see the static state section
    • also see http://stackoverflow.com/questions/2223386/why-doesnt-java-allow-overriding-of-static-methods
• Ok, so what to use if not static methods? We can define a factory class and make instances of it - this is OO

  • But to create the factory class instance we need a constructor:

    new CarFactory().makeCar('blue')
    

  • so we are in a problem loop!
• A better solution is to use Dependency Injection (DI framework)
  • That is reasonable, but requires an extra-lingual framework and adds a dependency
  • DI frameworks are workarounds for the lack of support in the underlying language

• 30+years old, Smalltalk
• There are no constructors in Smalltalk, instead, there are factory objects for instances (instance creators).
  • This is a solution we were trying to show in the above Java-like examples using factories.
  • In Smalltalk abstraction is preserved (we have an object as a target for new).
  • But inheritance instance initialization is not guaranteed - has to be worked on, does not come for free, see the next heading.

• Saving the following Car class declaration creates the class object (=the factory object for instances).

  "Defining and saving Car"
  
  Object subclass: #Car
    instanceVariableNames: 'color'
    classVariableNames: ''
    poolDictionaries: ''
    category: 'AAATUG'
  
  "Unlike Java new Car('blue'), or even CarFactory in /CarFactory.makeCar('blue')/, "
  "   Smalltalk Car class is an object, not just a static global name"
  "   Below, >>new is invoked on a target which is an object, instance of Car class, not a compile-time wired call"
  myCar := Car new.
  

• The fact that Car class is an object allows abstraction and method lookup etc.

In the Smalltalk Car definition, we defined instanceVariableNames: color to illustrate this point.

• We want the Smalltalk car to be created initialized with it's color.
• We do not want clients to call Car new.

myCar := Car new. 
myCar printMe. "myCar's color not initialized"

• To guarantee clients will not call Car new, we must override Behavior>>new or Behavior>>initialize and throw exception in the override
• Otherwise, if Car new is used by clients, myCar color value is not initialized
• The core issue here is that:
  • the instance of Car class (the factory for car instances) is a subclass of Object class (the factory for object instances)
  • along with method inheritance (new is inherited in the above case)
  • lead to the unintended ability to partially initialize myCar with color null if called as myCar := Car new.
• If this was not the case, Car class instance would not have access to Object class instance new message!
• Solving the above issue, is the core to better constructors (instance creators) in Newspeak, removing both the Java-ism issues (no object target) and Smalltalk-ism issues (incomplete initialization must be manually prevented).

Find an Example.

• Newspeak combines Scala constructors with Smalltalk factory for instances.

• But unlike Smalltalk, one cannot call a superclass's constructors on a subclass. This prevents clients from partially instantiating an object, say by writing:

  Car new. (* not visible and illegal as long as Car defines Car color: *)

Let us create a simple class in Java, Smalltalk and Newspeak: Thing and Car:

• In Smalltalk: Thing's subclass Car

  Thing: subclass Car
      instanceVariableNames: 'color'
      ..etc..
  
  'and class side method to create instances initialized with color'
  
  Car>>initWith: aColor
    |car|
    car := Car new. "or self new; not self initialize"
    car setColor: aColor.
  
    ^car.
  

  • Smalltalk Problem: Unless special care is taken (overriding >>new), client code can still call myCar = Car new and leave uninitialized state (instance variable color)

• In Java: Car extends Thing

  class Car extends Thing {
    String color;
    Car(String aColor) {
      this.color = aColor;
    }  
  }
  

  • Java Problem(s):
    • Java client call such as myCar = new Car('blue') will always be wired to the concrete type Car causing issues with testability, leading to need of Dependency Injection frameworkd.
    • myCar = new Car('blue') is a wired-in non object oriented syntax - new is not a message to a receiver object, cannot

• In Newspeak: class Car = Thing ()()

  (* 
     - TODO - Repeat Car constructor from previous section here:
  *)
  

• How is the Newspeak constructor different from the constructors in Java and instance creators in Smalltalk, and how does it solve the issues discussed? A summary from ¹¹:
  • Because the Newspeak instance is created by sending a message to an object, and not by a special construct like a constructor invocation Java: car = new Car('blue'), we can:
    • Replace the receiver of that message with any object that responds to that message.
    • The receiver can be another class, or it can be a factory object.
  • But Newspeak also solves, without need to extra care in defining Car, the Smalltalk initialization issues (non-initialization, multiple utilization's)
    • Newspeak client code:
      • Thing new printMe. #'I am a thing.'
      • BUT: Car new printMe => Does not understand Car>>new! which is good - Newspeak hid the ability to call "new"

      • SO: client use of Car color: 'blue'. is enforced instead of Car new:

        (Car color: 'blue') printMe. 'I am a Car, my color is blue'

Let us assume a factory method to make cars:

makeCar: carFactory = (
  ^carFactory color: 'blue'.
)

(* Can be called as *)
makeCar:  Car

(* But also as *)

makeCar: RGBCar

(* Where *)
class CarLibrary = Object()(

  class RGBCar rgbColor: aRgbColor = Thing (
    (* initializer *) 
    | 
    rgbColor ::= aRgbColor.
    | 
  )( 
    (* instance methods *)
    'category convert rgbColor to string color'
    public color = (^ rgbColor, 'converted to String name') (* call some converter From RgbColor To String *)

    'category show'
    printMe        = (^ 'I am a RGBCar, my rgbColor is ', rgbColor.)
  ):(
    (* class method which provides, for the RGBCar 
       an EQUIVALENT OF the /Car color:/ constructor,
       But this method returns RGBCar.
    *)
    'secondary constructor for RGBCar'
    public color: aColor = (
      |aRgbColor |
      aRgbColor: (aColor, ' converted to RGB'). (* hack - should call a converter stringColorToRGB:*)

      (* return instance or RGBCar *)
      ^rgbColor: aRgbColor
    )
  )

)

Clients may call the RGBCar using either one of the color: rgbColor constructors, as follows:

(RGBCar rgbColor: '#FFCCCC') printMe -> 'I am a RGBCar, my rgbColor is #FFCCCC'

or

(RGBCar color: 'blue') printMe. -> 'I am a RGBCar, my rgbColor is blue converted to RGB'.

The ability to take the Car class and create a different version of it, named RGBCar is also an example of Representation Independence in Newspeak - we can now delete Car, and rename RGBCar to Car, and no clients will notice , because:

1. Clients can still create the Car the same way as before (no need to change the client code):

   (renamed from RGB)Car color: 'blue'.
   

   Because a "legacy" color: constructor was provided as a class method.

2. Clients can still send color to Car:

   (renamed from RGB)Car color: 'blue' color.
   

   • This is because we provided, in RGBCar, the "legacy" color method

Altough note that we only pseudo-implemented the color method, the result in our case is not 100% the same, but making it the same is just a matter of mechanics of a converter between color and RGB col

• We have shown an example of a nested class with more comments in the section
• Nested classes are used (and needed) to implement plumbing often "solved" by static state.

From ¹²

• "The only widely used language that supports such nesting is Java. Java nested classes are used in very restricted, stylized ways. They are often used simply for packaging; the nested classes are static and the scope of the enclosing class is inaccessible to them so the issue does not arise. The situation in Python is similar: nested classes have no access to the scope of their enclosing class. Aggressive use of class nesting offers considerable possibilities. In addition to the classic techniques using nested and especially virtual classes [MMP89] demonstrated by the Beta community, nested classes can enable powerful features such as mixins, class hierarchy inheritance and modules."
• (But the actual mechanism how this happens is hard for me to understand, see the reference above if you are interested)

We will only make a few notes without much reasoning, referring to ¹² once again:

1. In Newspeak, all names, including class names, are late bound
   • So at runtime, there can be more than one instance of a class for a class name (classes are virtual - this is different from other OO languages such as Java or Smalltalk).
   • Because of class declarations (and hence superclass declarations) are virtual, all classes act as mixins.
   • Because a module is just a top level class, also module definitions are mixins
2. All nested classes are virtual
   • So, also entire libraries/frameworks can be inherited, mixed-in, overridden

Static state (variables) have known issues, most of those mentioned here are directly from ¹³

Static variables are:

• Bad for security: If your code is attacked, the attacker has access to everything your code does, including static state. Attacker can do things like:
  • Smalltalk at: #Transcript put: TranscriptWhichForwardsToAttacker. 'Smalltalk is static and holds other static state'
  • And if your code logs credit card numbers, or social security etc , the attacker can read them. (Assume attacker code can reach out of your network)
• (Mutable static variables) are bad for re-entrancy - see also http://en.wikipedia.org/wiki/Reentrancy_%28computing%29
• Bad for concurrency (ability to run on multiple threads/cpus) - see the above link as well
• Complicates memory management / garbage collection
• Bad for startup time - I think this applies to static methods as well, code using static methods must load the class etc.
• Bad for distributed systems, need to be at one place or constantly synced
• Bad for testability

Quotes from Room 101 on static state ¹³:

"It may seem like you need static state, somewhere to start things off, but you don't. You start off by creating an object, and you keep your state in that object and in objects it references. In Newspeak, those objects are modules.

Newspeak isn't the only language to eliminate static state. E has also done so, out of concern for security. And so has Scala, though its close cohabitation with Java means Scala's purity is easily violated. The bottom line, though, should be clear. Static state will disappear from modern programming languages, and should be eliminated from modern programming practice."

Eradicating all state is good but outside the scope of this discussion (as they say to not enter wars)

But the world needs persistence, so need to pass state through some kind of IO for persistence read/write. Proponents of "no state" rarely discuss this need.

It seems to me there always need to be a boundary where state needs to be conveyed from and to a calculation (IO).

• Why?
  • In both cases, there is no runtime object that is a target of the operation
  • No runtime object, so no interface that can be used to describe the operation (abstraction)
  • No runtime object, so no dynamic binding

To discuss modularity in Newspeak, there are two important concepts: Nested classes and Imports. We described class nesting before. We will show what is meant by imports in this example.

Let us work out a simple example. Let us say we have a Newspeak module CarRace. The module needs a DatetimeLibrary to calculate a difference between "finish time" and "start time".

Let us choose a datetime library (that we wrote) which has a bug in it. Call this DatetimeLibraryBuggy.

Upon discovering the bug, we would like to switch to a different datetime library. Call this DatetimeLibraryCorrect.

How can this be illustrated in Newspeak?

The buggy datetime library/module is a top level class:

(* A datetime library (module) with a bug - elapsed time returns a negative number. 
   Illustration only/
*)
class DatetimeLibraryBuggy = Object () (
  class Datetime = Object (
    (* No initializer code, no slots in this illustration example. *)
  )('misc'
    (* Single method elapsedTimeBetween: and:  - illustration only. 
       Result hardcoded to always return a negative 10 minutes as String
    *) 
    elapsedTimeBetween: start and: finish = (^ '-10 minutes'.)
  )
)

The correct datetime library/module is a top level class as well:

(* A datetime library (module) without a bug - elapsed time returns a positive number. 
   Illustration only.
*)
class DatetimeLibraryCorrect = Object () (
  class Datetime = Object (
    (* No initializer code, no slots in this illustration example. *)
  )('misc'
    (* Single method elapsedTimeBetween: and:  - illustration only. 
       Result hardcoded to always return a positive 10 minutes as String - considered always correct for illustration.
    *) 
    elapsedTimeBetween: start and: finish = (^ '10 minutes'.)
  )
)

The CarRace module (which is also a beginning of a Newspeak Application)

(* CarRace: a Newspeak module: Illustration of modularity, not a real example.
   parameters platform, carLibrary and dateLibrary are the only way to pass
   any piece of information to the module (no global or static state).
*)
class CarRace usingPlatform: platform usingCarLibrary: carLibrary usingDatetimeLibrary: datetimeLibrary = Object (
  |
  (* List (Car, Datetime, etc) each defines a slot. 
     List's value (platform collections List) is a List class in the platform. 
     The slot definition of List and other slots function as an *import* statement, without a need for an /import/ keyword.
     The platform is only in scope in the initializer - programmer must take action to get from it what is needed.
     All modules' external dependencies can all be gleaned in this initializer section.
  *)
  private List = platform collections List. (* unused *)
  private Car = carLibrary Car.
  private Datetime = datetimeLibrary Datetime.
  private Transcript = platform blackMarket Transcript.
  |
)('misc'
  runRace = (
    |blueCar redCar blueStart blueFinish redStart redFinish|
    blueCar: (Car color: 'blue').
    blueStart: '10:25'.
    blueFinish: '10:35'.

    redCar: (Car color: 'red').
    redStart: '10:25'.
    redFinish: '10:35'.

    Transcript open show: 
      'Tied race: Car with color ', redCar color, ' took ', (Datetime new elapsedTimeBetween: redStart and: redFinish),
                ' Car with color ', blueCar color, ' took ', (Datetime new elapsedTimeBetween: blueStart and: blueFinish).
  )
)

To run the CarRace client code using the buggy datetime library, paste the following in workspace:

• ==>

  |carRace|
  carRace:: (CarRace usingPlatform: platform 
                     usingCarLibrary: CarLibrary new 
                     usingDatetimeLibrary: DatetimeLibraryBuggy new
            ).
  carRace runRace.
  

Migrating client code to use the correct datetime library is a matter of switching the imported module from DatetimeLibraryBuggy to DatetimeLibraryCorrect

• ==>

  |carRace|
  carRace:: (CarRace usingPlatform: platform 
                     usingCarLibrary: CarLibrary new 
                     usingDatetimeLibrary: DatetimeLibraryCorrect new
            ).
  carRace runRace.
  

• A Newspeak application is an object conforming to a standard API. The application API is defined by the presence of one instance method:

  main:args:

• A Newspeak application can be deployed either as NOF file or as an image. To deploy as a NOF file, the application must also define a class method

  packageUsing:

• We will glean the parameters passed to main:args: and packageUsing: from the example.

• Let us create a CarRaceApp which main:args: method instantiates the CarRace object, using the imported modules.

  (* CarRaceApp is a Newspeak application, deployable as NOF file. 
  
    - The /packageUsing: topNamespace/ constructor allows to deploy as a NOF file.
  
    - The /topNamespace/ is effectively the Newspeak namespace and allows 
      the application packager to wrap classes and objects into the NOF file
  
    - The /main: platform args: systemArgs/ instance method turns the class into an application.
      It's presence is picked up by the Newspeak IDE which then adds facilities to run and package the app.
      These facilities are the [deploy] and [run] clickable links on the top right of the class declaration.
  
  *)
  
  class CarRaceApp packageUsing: topNamespace = Object (
    |
    CarRace = topNamespace CarRace.
    DatetimeLibraryCorrect = topNamespace DatetimeLibraryCorrect.
    CarLibrary = topNamespace CarLibrary.
    |
  )('turn class into application'
    main: platform args: systemArgs = (
    |carRace|
    carRace:: (CarRace usingPlatform: platform 
                       usingCarLibrary: CarLibrary new 
                       usingDatetimeLibrary: DatetimeLibraryCorrect new
              ).
    carRace runRace.
    )
  )
  

• Paste the above code for the CarRaceApp into a top level class. Notice that on "accept" (clicking the checkmark or do Ctrl-S), two icons appear on top of the class definition: [deploy] and [run]. State after accepting the above code:

  

• Click on [run] and a Transcript showing Tied race: "Car with color red took 10 minutes Car with color blue took 10 minutes" should show:

• Click on [deploy] and select "As NOF". Notice that a CarRaceApp.nof file appeared in the directory where Newspeak runs:

  

• How to Run the Application Saved in the NOF file?

  • Currently, there appears no way to run the NOF from outside the Newspeak IDE. I assume that is intended to be changed?
  • To run the CarRaceApp.nof from inside the IDE, click on the Settings wheel , and select "Run App". A dialog will appear which allows to select the NOF file.

  

  • Notes:
    • On NOF: Currently there seems to be no practical difference between running from the Settings wheel and clicking on the [run] link. I assume that will change and we will be able to run the NOF file from the operating system outside the Newspeak IDE(?).

    • On other formats of creating an application. Clicking the [deploy] link allows to choose from:

      • as NOF
      • as Packaged Image
      • as Dart
      • as JavaScript

      The last two point to an exciting prospect of running your application directly from the browser, but at this point there is not enough documentation. I tried to generate the JavaScript application and run from a web browser, but nothing was shown. Need to spend more time on this.