Free visualworks smalltalk software for mac

BottomFeeder is a news aggregator client (RSS and Atom) written in VisualWorks Smalltalk. It has full support for CSS, including user defined CSS.

Main features:>
- Full support for CSS, including user defined CSS.
- View news in 3 pane or 2 pane modes.
- Subscribe to any RSS or Atom format in use.
- View items in a summary Newspaper View.
- Synchronize 2 or more BottomFeeders via HTTP or file import.
- Subscribe to feeds or feedlists.
- Supports HTTPS, HTTP Authentication, and HTTP Digest Authentication.
- Plugins for blogging, IRC, and MSN Messenger contacts.
- Easy to update or upgrade from within BottomFeeder.
- Save as many or as few feed items for as long as you want.
- Import or Export in common OPML format.
- Binary compatible on every platform. No need to recompile.

OCUnit is a testing framework for Objective C in the MacOSX and WebObjects environment. It is based on SUnit, Kent Becks Smalltalk testing framework, also available for Java under the name JUnit.
With OCUnit, testing becomes integrated with development. You can test frameworks, bundles, or applications.
OCUnit is distributed as open source.
Main features:
- SenTestingKit, a framework to help you write test cases;
- otest, a testing tool;
- a collection of Makefiles and utilities to seamlessly integrate testing with Xcode and ProjectBuilder
- Object-oriented tests.
- Very low overhead.
- Tests are in the same language as the implementation.
- Test case classes cohabit with classes they test.
- Promotes aggressive refactoring.
- Helps capture requirements, expose dependencies.
- Total integration in the development process.
- Records testing expertise.
- Tests frameworks, bundles, or applications.
- Easy installation
- No license fee.
Enhancements:
- Make sure Foundation is loaded before SenTestingKit.
- Added autorelease pool to detect over-releases faster.
- Added license to all source files.

Io is small prototype-based programming language. The ideas in Io are mostly inspired by Smalltalk (all values are objects), Self (prototype-based), NewtonScript (differential inheritance), Act1 (actors and futures for concurrency), LISP (code is a runtime inspectable/modifiable tree) and Lua (small, embeddable).
Main features:
- open source BSD license
- pure object language
- small VM (~16K C statements, 8K Io specific)
- small memory footprint (between 64K-200K depending on the platform)
- reasonably fast (comparable to Python, Perl, Ruby)
- incremental collector, weak links
- differential prototype-based object model
- dynamic typing
- exceptions
- ANSI C implementation (except for coroutines)
- embeddable
- multi-state (multiple VMs can run in the same application)
- actor-based concurrency
- coroutines
- 64 bit clean.

StepTalk is the official GNUstep scripting framework.
It is more than a scripting framework with an illusion of single objective environment between objects of scriptable servers or applications. It is language independent, but the default scripting language is Smalltalk.
Enhancements:
- The framework was ported to Mac OS X.
- The new StepTalking application was added.
- The StepTalkKit framework was added, and includes a new conversation window class with default context, a customizable toolbar, script history, and language selection.
- New view classes were added for custom script input/output.
- An AppKit bundle is included.
- The source was reorganized into more logical groups.
- Foundation and AppKit bundles now advertise all public Cocoa classes.
- Constants from Foundation and AppKit are generated from a simple constants list file.

F-Script 2.0 is such an effective open-source scripting layer which is specifically designed for the Mac OS X object system (i.e. Cocoa). F-Script provides scripting and interactive access to Cocoa frameworks and custom Objective-C objects. It aims to be a useful and fun tool for both beginners and experts, allowing interactively exploring, testing and using Cocoa-based objects and frameworks.

Major Features:

1. The F-Script shell provides an interactive command line interface for manipulating Objective-C objects.
   • Use a fully featured object-oriented shell.
   • Manipulate objects interactively or write scripts.
   • Save and load objects easily.
   • Express complex object manipulations quickly and easily with a high-level programming model.
   • Access the Cocoa frameworks as well as your own Objective-C objects.
2. The object browser lets you graphically find, explore and manipulate objects.
   • Explore objects and methods.
   • Browse Objective-C instances and Objective-C classes.
   • Quickly locate attributes and methods with the search field.
   • Graphically Invoke methods.
   • Navigate Cocoa bindings.
   • Explore Core Data objects graphs.
   • Select objects on screen with the "Select and browse" magic button.
   • Add custom actions to the browser.
3. Powerful tools let you inspect objects.
   • Query Core Data interactively.
   • Explore Cocoa collections (arrays, dictionaries, etc.)
   • Edit and run scripts.
   • Inspect Cocoa objects.

Enhancements:

• 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...
• 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.
• 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
• 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.0 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.0 also includes a developer version of F-Script Anywhere 2.0, which allows injecting F-Script into any Cocoa application.
• 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:
  • 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.
• Direct access to the latest Mac OS X technologies: F-Script 2.0 lets you directly access a number of the latest Mac OS X frameworks. And other ones are just a simple loading instruction away.
• New project infrastructure: The source code for F-Script is now available at Github

Requirements: Requires Mac OS X 10.5 or later

Mops 4.01 is a convenient program for Forth and Smalltalk parentage, which comes with extensive OOP capabilities including multiple inheritance, and a class library supporting the Macintosh interface.

Enhancements:

• Release notes not available at developer site nor in download at the time of this posting

Requirements:

• Mac OS X 10.3.9 or later.