Jonathan Sterling discusses writing fully native Cocoa applications in Smalltalk with F-Script in "Writing Mac OS X applications in Smalltalk"

What I really wanted was a version of Smalltalk that used the same object model as Objective-C, like Pragmatic Smalltalk of Etoilé, or even MacRuby on Mac OS. Most of all, I wanted it to treat me like an adult: I don't need a class browser, thank you, I'm more comfortable working with plain-old files. The persistent image construct in Smalltalk really makes me uncomfortable. Eventually, I found F-Script, a scripting environment for Mac OS based on Smalltalk. It is not really meant for developing full applications, but with a little work, I was able to make this work. Read more…

Fabian Schuiki explains how F-Script can be used as a debugging tool when developing Cocoa applications in "F-Script: The Ultimate Debugging Console".

If it weren’t for F-Script, I would have spent 5 hours today writing debugging code and creating some testing UI for Artifica which would have been another source for bugs which increases complexity of the debugging process again. F-Script gives you the possibility to completely split up the development of your object model and your view model, which not only saves you a lot of time and is more productive, but is also less frustrating since you never have to go figure whether your app’s functionality is broken due to a bug in the UI, the object model or even worse, somewhere in between. Read more…

The french Ruby and Smalltalk communities are organizing the first BlockCamp event in Paris on the 28th november 2009. I will be there and will talk about F-Script 2.0. Come join us! More information here…

In this fun video clip, it takes Jeff only a few seconds to bring support for Snow Leopard’s text substitutions to WriteRoom… Cool demo of F-Script injection, for those unfamiliar with it.

Blocks (aka lambda expressions or closures) are versatile and powerful. I like them. I have even implemented a programming language in which they play a central role.

However, for a number of common programming situations, I think that some alternative approaches based on higher order messaging provide better solutions than classic block-based approaches. Marcel Weiher provides a good example in Blocked-C. He shows some Objective-C code that uses a block to iterate over a collection of strings and to create a new collection with some suffix added to the original strings:

 NSMutableArray *filteredItems = [NSMutableArray array];
 [items enumerateObjects WithOptions:0 withBlock:
    ^(id item, NSUInteger index, BOOL *stop) {
       [filteredItems addObject:[item stringByAppendingString:@"suffix"]];
    }
 ];

Then, he goes on to show how the same can be achieved using a higher order messaging (HOM) technique:

 [[items collect] stringByAppendingString:@"suffix"];

The conciseness and expressiveness of the HOM version is impressive and should at the very least warrant further examination. Regarding this, we are lucky since this approach, and its application to Objective-C, is described in an OOPSLA paper titled "Higher Order Messaging" (download).

With some support in the programming language, higher order messaging techniques can go even further. F-Script is a Smalltalk dialect for Cocoa which extends Smalltalk with array programming and messaging patterns. Messaging pattern is a generalization of message sending that applies to entire collections of objects. In a number of common situations, this provides an interesting alternative to the classic block-based approach. Indeed, here is our example coded in F-Script:

 items stringByAppendingString:'suffix'.

A key aspect of this programming model (and of Weiher’s HOM) is that it liberates us from the classic "one object at a time" style, and lets us manipulate whole collections of objects at once, using higher level constructs. We are freed from the low level details of accessing and dealing with individual elements. In my experience, introducing array programming in object-oriented programming, as F-Script does, has positive effects similar to those of the introduction of vectors in math, which is quite nice… This model is described in another OOPSLA paper titled "OOPAL: Integrating Array Programming in Object-Oriented Programming" (download)

To get a better sense of this programming model, let’s see how it stacks up against classic block based approaches for collections manipulation as seen in Ruby and Smalltalk. For the same price, I also add Python’s list comprehensions and C# Linq to the mix. In some common situations, those are interesting alternatives to blocks that are still representative of the "one object at a time" approach.

In the example below, we have a list of songs (a collection of Song objects) and we want to get their names. Here is how we’d do it using various approaches:

• Smalltalk and Ruby with blocks
• Python with list comprehension
• C# with Linq
• F-Script with array programming

We can note that the array programming version (F-Script) is free from syntactic noise and low-level iteration logic, as is the brain of the programmer. Actually, in that particular situation, it seems hard to do better.

For the ruby version, we use a feature adopted in Ruby 1.9, which allows for automatic conversion of symbols to blocks. This is a useful trick as it provides a way, in some situations, to have a compact notation for some kind of blocks. Note, however, that when we need to provide more that just a method name, we have to use the classic Ruby block notation. This is the case in our original example (i.e., invoking the stringByAppendingString method with a given argument), for which we would have to do: items.collect {|item| item.stringByAppendingString("suffix")}.

We can carry on the comparison further by introducing some need for filtering. In the following example, we want to get the names of songs with a bit rate greater than or equal to 256 kb/s.

We see that the F-Script programming model allows for conciseness and expressiveness. Note that, in F-Script, where: is not a keyword or a special construct. It is just a regular message selector. The where: method, defined in a category of NSArray, takes an array of booleans as argument and returns the elements of the receiver whose positional matching element in this boolean array is true. Such boolean array is exactly what is produced by the expression songs bitRate >= 256, as messages are automatically broadcasted to each individual elements of the receivers (i.e., the bitRate message is sent to each element of the songs array, producing an array of numbers whose elements are then sent the >= 256 message, producing the array of booleans). This is the powerful compression operation of array programming adapted to object-oriented programming.

Finally, here is an example of sorting a collection of objects. In this example, we want to create a sorted collection of our songs, sorting on the songs’ names. In the case of Python, since its list comprehensions don’t have specific support for sorting, we use a solution based on lambda expressions.

As in the previous examples, the F-Script version shows that we can do sophisticated collection manipulation without relying on blocks but only using message passing. The result of the sort message sent to the array of song names is an array of integers containing the indices that will arrange the receiver of sort in ascending order. We then pass this array of indices to the at: method. The at: method allows for indexing an array by either a single integer or a whole array of indices. This is this latter capability, a fundamental element of array programming, that we use here to produce our sorted list of songs.

Conclusion

Blocks are great, especially in programming languages which don’t have (and don’t want) specific syntax for classic control structures (if/then/else, while, etc.). However, we should take them with a grain of salt and see that, for some common problems, there are alternative approaches that are worth considering.

Further reading

F-Script documentation set
Blocked-C II
Can Programming Be Liberated from the von Neumann Style? A Functional Style and Its Algebra of Programs

Special bonus

You can easily, and interactively, experiment with the code provided in the examples: launch F-Script.app, connect to iTunes and immediately start querying and manipulating your iTunes song collection from F-Script.

You connect to iTunes using the standard Cocoa Scripting Bridge technology. For example, you can enter the following code in the F-Script console:

iTunes := SBApplication applicationWithBundleIdentifier:'com.apple.iTunes'

The iTunes variable now points to a dynamically generated Cocoa object that stands for the iTunes application.

You can get at your songs with:

 songs := ((iTunes sources at:0) playlists at:1) tracks

You can then directly paste, in the console, the code of the examples provided in this article. If your song library is huge you might notice some latency, as Cocoa messages are automatically converted to Apple Events that flow back and forth between F-Script and iTunes.

Stepwise has been removed from the universe. It was one of my favorite Web sites back in the 90’s and, I think, a mythical place for many NeXT and early Mac OS X developers. I remember, among other things, the wonderful WWDC reports published there.

Thanks to Scott Anguish and everyone involved.

The NSConference 2010 setup looks great. I’ve been lucky to attend and speak at the 2009 edition, which was terrific, thanks to the vision, work and human qualities of the folks at MDN, Steve Scott and Tim Isted. The videos of the 2009 edition are all available for purchase. This includes the talk I gave on “New Cocoa programming superpowers”.

There are also a number of backstage and interview videos at Pomcast.com (search for "NSConf"), including the super geeky Hacking F-Script & Pick&Play, starring Jason Harris, and the french F-Script interview in the dark.

Cédric Luthi takes control of Preview.app with F-Script Anywhere in "Watch a large number of icons with Preview.app".

F-Script injected into the Finder:

Looking around with the object browser. Cocoa all over the place!

The NSApplication singleton and its delegate… So cute!

Have you ever seen the Finder’s Cover Flow from the inside? Look at that setFog: method on the IKImageFlowCell… Yummy!

Ultimate proof that the Finder makes use of bindings:

Seems that the names of the Finder specific classes start with ‘T’. Oh well…

Don’t click on that “switchToSimpleFinder” method or else…

That black Cover Flow background is boring. With F-Script, we can change it to something more disco!

Garbage collection

New in F-Script 2.0 is a fast, concurrent, generational garbage collector. It was a lot of work to implement. Fortunately, Apple did all of it, as F-Script 2.0 uses the new Objective-C garbage collector. As with Objective-C, when you run F-Script in GC mode you no longer have to manage retain counts and to care for cyclic references. You can still use F-Script in non-GC mode, which is needed if you want to interact with non-GC capable frameworks or libraries. A new option in the F-Script preference panel let you choose your memory management model. Finally, you can embed F-Script in GC or non-GC applications.

Garbage collection is performed concurrently, on its own thread. Another notable aspect is that it works both for objects and for raw memory buffers. Actually, for raw memory buffers, you can either use managed or unmanaged memory. F-Script 2.0 lets you use unmanaged memory as usual (i.e., with the malloc: method) and introduces new methods, in the FSPointer class, for dealing with managed memory. Features such as weak references, explicit GC control, etc. are all available from F-Script using the standard methods provided by Cocoa.

64-bit

F-Script 2.0 provides 64-bit support. Benefits include:

• Very large virtual address space
• New Objective-C runtime (optimized message dispatching, zero-cost setup model for exceptions, etc.)
• Ability to load 64-bit frameworks in F-Script and to embed F-Script in 64-bit applications

You can still run in 32-bit mode and you can use the F-Script framework in 64-bit and 32-bit applications.
The F-Script API itself now exposes both 64-bit and 32-bit capable interfaces, using Cocoa’s NSInteger, NSUInteger and CGFloat macros.

New object browser

The graphical object browser gains a new look and a number of enhancements. This includes:

• Introspection of Objective-C 2.0 properties
• Improved introspection of bindings
• Direct access to the view hierarchy
• Visual feedback when selecting graphical components on screen
• Additional information about standards Cocoa objects
• And more…

Companion article: Exploring Cocoa with F-Script
Discover the graphical object browser and object inspectors in this in-depth article.

If you are a Cocoa developer, you already know that the dynamic nature of Objective-C and Cocoa is what makes them so flexible and powerful. In terms of development tools, the power of a dynamic object-oriented environment like Cocoa translates into original tools like Interface Builder or F-Script, an open source project that is presented in this article. F-Script is an integrated set of tools that makes it possible to interactively explore and manipulate Cocoa objects as well as script them using new high-level programming techniques. This article shows you how to use some of its most impressive features and demonstrates how it can be a useful addition to your developer toolkit. Read more…

Dynamic Cocoa class creation

F-Script 2.0 makes it very easy to dynamically define new classes. At run-time, these dynamically generated classes are regular Cocoa classes that happen to execute F-Script code instead of compiled Objective-C code. They can be used from both F-Script and Objective-C. You can subclass existing Cocoa classes in F-Script and, as in Objective-C, define instance variables, instance methods and class methods. In addition, F-Script also supports defining class instance variables.

Companion article: Creating Cocoa Classes with F-Script

F-Script 2.0 provides a handy syntax for dynamically creating Cocoa classes on the fly. This is useful for quickly experimenting, prototyping and using Cocoa interactively, as well as for developing sophisticated programs. You can type a class definition in the F-script console, hit return and immediately start playing with your new class. This article provides a quick introduction to this feature. Read more…

System-wide scripting

F-Script 2.0 is able to control scriptable applications and graphically browse and interact with the applications scripting interfaces. This major new feature is based on the MAC OS X Scripting Bridge technology. For example, here is how you can connect to iTunes:

iTunes := SBApplication applicationWithBundleIdentifier:'com.apple.iTunes'

You can then manipulate iTunes from F-script. For example, here is how you make iTunes go to the next track:

iTunes nextTrack

Companion article: System-wide Scripting with F-Script
Learn how to script your applications with this tutorial.

Like AppleScript, F-Script can communicate with scriptable application, making it possible to automate processes using these applications and to create workflows spanning multiple applications. This system-wide scripting capability relies on a standard Mac OS X technology called the Scripting Bridge. Basically, the scripting bridge allows manipulating scriptable applications as if they were Cocoa objects, automatically taking care of the communication details (e.g. creating and sending Apple Events). This allows using F-Script to manipulate other applications through their standard scripting interface. Read More…

Updated embedding and injecting capabilities

F-Script can be easily embedded into your own applications or dynamically injected at runtime into any running Cocoa application. Embedding is great for adding scripting or interactive object querying/manipulation capabilities to your applications, as well as for implementing parts of your apps with F-Script. Injecting is incredibly powerful when it comes to debugging or exploring the innards of applications. F-Script 2 comes with full support for the new plugin model of Interface Builder 3, allowing drag and drop of F-Script graphical components right into your application. F-Script 2 also includes updated injecting tools (aka F-Script Anywhere) which lets you inject a complete F-Script environment at run time into any Cocoa application.

Companion article: Embedding F-Script into Cocoa Applications

All F-Script functionalities are available through components which can be integrated into applications. This enables you to: Program all or part of an application using the F-Script language. Offer a scripting environment within your applications, allowing users to manipulate your business objects and to automate processes. Interface F-Script with other tools. Because F-Script and Cocoa share the same object model, integration is easy and advanced. Read more…

Refined syntax and class library

F-Script is a Smalltalk dialect. As such, its syntax is well suited to the manipulation of Objective-C objects, since Objective-C itself borrowed its messaging syntax from Smalltalk. F-Script 2.0 introduces several syntax refinements, including a handy notation for specifying dictionaries. Here is how an NSMutableDictionary instance with two entries looks like:

#{key1 -> value1, key2 -> value2}

There are other syntax enhancements including support for Unicode in string literals and a hexadecimal notation for numbers. Besides, the base class library has been refined, with new methods for dealing with collections, new globals for easy access to the standards IO streams, a new facility for comparing objects with the special nil value and some changes in the way test for object equality is performed. It is also worth noting the introduction of a new public class, FSAssociation, which represents associations between two objects, a “key” and a “value”, and is primarily used for specifying dictionary entries.

If you are not familiar with the F-Script syntax and fundamental elements, the two articles referenced below will get you up to speed in a breeze.

Companion article: Learn F-Script in 20 Minutes and Have Fun Playing with Core Image

In this article, our goal will be to produce a nice little animation using fancy Core Image effects. In doing so, we will learn the basics of F-Script. So install yourself comfortably in front of your Mac, download the latest F-Script version from http://www.fscript.org and enjoy the trip! Read more…

Companion article: Scripting Cocoa with F-Script

One important application of Cocoa’s openness is its integration with scripting languages. This is very useful because it allows for interactive use and easy gluing of Cocoa components. In this article I want to give you a taste of Cocoa scripting, and to show you the level of integration that you can expect. We will use F-Script, an open source scripting language for Cocoa, to build a little graphical application. Using F-Script, we will directly program against the Application Kit, which is the Cocoa object framework for graphical user interfaces. Read more…

Snow Leopard

F-Script 2 is compatible with both Leopard and Snow Leopard. It lets you directly access a number of the latest Mac OS X frameworks. And other ones are just a simple loading instruction away.

Companion article: Accessing Mac OS X Frameworks with F-Script

F-Script.app, the standalone F-Script environment, is automatically linked with a number of Mac OS X frameworks. This is convenient for quickly exploring Mac OS X’s capabilities and directly using the frameworks without any further configuration. Read more…

New project infrastructure

The source code for F-Script is now available at Github.

New group for support and discussions: http://groups.google.com/group/f-script/.