| Welcome to Dolphin Smalltalk X6 |
| What's New in Version 6? |
| Products |
 | Dolphin Community Edition |
| Dolphin Professional |
| Development Tools |
| Editor |
| Go Search |
| Idea Space |
| Source Tracking System |
| Method Explorer |
| View Composer |
| View Browser |
| Executable Browser |
| Code Mentor |
| Rewrite Tool |
| Compiler and Virtual Machine |
| True Block Closures |
| Improved Garbage Collector |
| Immutability Support |
| Class Library |
| Sockets |
| Literal Filer |
| Slidey Inney Outey Things |
| Other New Views |
| Documentation/Help |
| Newcomers Start Here |
| Getting Started |
| The Dolphin Smalltalk Product Range |
| Dolphin Community Edition (DCE) |
| Dolphin Professional (DPRO) |
| Installation |
| System Requirements |
| Setup |
| Fresh Install: Unlocking the Installation |
| Installed Files |
| The Image |
| Looking after Your Image |
| Save Your Image Often |
| Guided Tour |
| A Note to Those New to Smalltalk |
| Starting Dolphin |
| System Folder |
| System Folder Icons |
| Additional Tools Icons |
| Sample Applications Icons |
| Source Tracking Tools Icons |
| Workspace |
| Workspace Operations |
| Workspace Files |
| Class Browser |
| Class Hierarchy Pane |
| Category Filter Pane |
| Protocol Filter Pane |
| Variables Filter Pane |
| Method List Pane |
| Method Source Pane |
| Class Definition Pane |
| Class Comment Pane |
| Class Diagram Pane |
| Views Pane |
| Code Mentor Pane |
| Code Rewriter Pane |
| System Browser |
| Packages Pane |
| Class List Pane |
| Category Filter Pane |
| Protocol Filter Pane |
| Variables Filter Pane |
| Method List Pane |
| Method Source Pane |
| Class Definition Pane |
| Class Comment Pane |
| Class Diagram Pane |
| Views Pane |
| Code Mentor Pane |
| Code Rewriter Pane |
| Package Browser |
| Packages Pane |
| Package Comment Pane |
| Classes Pane |
| Loose Methods Pane |
| Views Pane |
| Globals Pane |
| Package Scripts Pane |
| Prerequisites Pane |
| Dependents Pane |
| View Composer |
| View Arena Pane |
| View Hierarchy Pane |
| Property Inspector Pane |
| Toolbox Pane |
| View Browser |
| View Categories Pane |
| View List & Preview Pane |
| Idea Space |
| Idea Space Cards |
| Protocol Browser |
| Protocols Pane |
| Selectors Pane |
| Conforming Classes Pane |
| Method Explorer |
| History Pane |
| Method List Pane |
| Source Pane |
| Debugger |
| Stack Pane |
| Temporaries Pane |
| Inspector Pane |
| Source Pane |
| Inspector |
| Published Aspects Pane |
| Instance Variables Pane |
| Visual Object Finder Pane |
| System Transcript |
| Class Diagram |
| Live Update |
| Process Monitor |
| Executable Browser |
| STS Tools |
| Source Tracking System |
| Method Editions Browser |
| Method Editions Pane |
| Method Comparison Browser |
| Class Editions Browser |
| Class Editions Pane |
| Class Editions Method List |
| Package Editions Browser |
| Package Editions Package Pane |
| Package Editions Pane |
| Package Editions History Viewer |
| Project Editions Browser |
| Projects Pane |
| Project Editions Pane |
| Contained Package Editions Pane |
| Changes Browser |
| Changes List Pane |
| Programming Cookbook |
| Creating GUI Applications |
| Model View Presenter Overview |
| Model |
| View |
| Presenter |
| Component-based Architecture |
| Pluggability |
| Flexibility |
| Pluggable Views |
| Pluggable Models |
| Why are Views Observers? |
| Sharing a Model |
| Creating MVP Components |
| Models |
| Presenters |
| Views |
| Elemental MVP Components |
| Composite MVP Components |
| Creating Console Applications |
| Architecture |
| Accessing Standard I/O Streams |
| Accessing Command Line Arguments |
| Calling C Runtime Library Functions |
| Accessing Environment Variables |
| Intercepting Console Control Commands |
| Testing and Debugging Console Applications |
| Debugging with Command Line Parameters |
| Error Handling |
| Deploying Console Applications |
| Distributing Console Applications |
| Deploying Applications |
| Lagoon Deployment Kit |
| Application Deployment Overview |
| Deployment Strategy |
| What to do when things go wrong |
| Lagoon Deployment Wizard |
| Initial Screen |
| Step 1 |
| Step 2 |
| Step 3 |
| Step 4 |
| Step 5 |
| Step 6 |
| Step 7 |
| Final Step |
| Lagoon Deployment Tutorial |
| Hello World |
| Distributing Your Application |
| Target Machine Requirements |
| Redistributable Components |
| Creating a Setup Program |
| External Interfacing |
| External Libraries |
| Parameter Conversion and Wrapper Methods |
| Caution: Objects may Move or Disappear |
| Returning Structures |
| External Methods |
| External Method Format |
| Parameter Types, Validation and Conversion |
| External Call Limitations |
| Overlapped Calls |
| Thread Affinity |
| To Overlap or Not to Overlap |
| Virtual Calls (C++/OLE COM Interface) |
| OLE/COM/Active-X Functions |
| External Structures |
| ExternalStructure |
| Dynamic Field Access |
| Compiled Field Access |
| External Structure Limitations |
| External Field Types |
| Scalar Fields |
| Pointer Fields |
| Embedded Fields |
| Filler Fields |
| Unions |
| Restricting Field Access |
| Structure Packing |
| External Arrays |
| Arrays of Scalar Values |
| Arrays of Structures |
| COM/.Active-X Array Types |
| External Memory Management |
| External Callbacks |
| ExternalCallback Objects |
| Callback Lifetime |
| Unwinding Callbacks |
| Debugging Callbacks |
| Callback Entry Points |
| Inbound Argument Conversion |
| Closure or User Data Arguments |
| MessageCallback Objects |
| Virtual Callbacks |
| Further Information |
| Exception Handling |
| Class vs Instance |
| Resumable vs Non-resumable Exceptions |
| General Categories of Exception |
| Errors |
| Warnings |
| Notifications |
| Raising Exceptions |
| Catching Exceptions |
| Catching Multiple Exceptions |
| Handling Exceptions |
| Exception Hierarchies |
| Exceptions vs. Unwinds |
| Win32 Structured Exceptions |
| How it works |
| Guidelines for Use |
| Weak References and Finalization |
| And finally?? |
| Weak References |
| How do Finalization and Mourning Actually Work? |
| The Rules |
| Zen and the art of Finalization |
| Binary Filing Objects |
| Storing objects |
| Storing globals |
| Retrieving objects |
| Mixing STB with other data |
| Customising storage |
| How to use an STB Proxy |
| Creating an STB Proxy class |
| Deferred fixup |
| Overriding a proxy |
| Making use of the filer context |
| Converting STB data after instance layout changes |
| STB Debugging |
| STB Exceptions |
| Chunk Files |
| Dolphin's Chunks |
| Classes |
| Methods |
| Expressions |
| Importing from other Smalltalks |
| Database Connectivity |
| Setting up a Sample Data Source |
| Connecting to a Data Source |
| Supplying a Username and Password |
| Choosing from a list of Data Sources |
| Querying the Capabilities of a Data Source |
| Querying the Database Structure |
| Executing SQL Queries |
| Navigating through a Result Set |
| Accessing a Row |
| Inspecting a Result Set |
| Executing SQL Statements |
| Preparing SQL for Later Execution |
| Preparation |
| Parameterization and Execution |
| Preparing Queries |
| An alternative method for describing columns |
| Transactions |
| Commit |
| Rollback |
| Read-Only Transactions |
| ODBC Error handling |
| Cleaning up |
| Bypassing finalization |
| Reinstatement on Image Re-load |
| Sockets Connectivity |
| The Socket Connection Interface |
| Blocking |
| Blocking the User Interface Main Process |
| Non-Blocking |
| Examples |
| Persistency of Sockets |
| Internet Addresses |
| Listening for a Connection with a ServerSocket |
| Establishing a Client Connection |
| Examples |
| Streaming over a Socket Connection |
| Talking Objects across a Socket Connection |
| Convenience methods for reading and writing objects |
| Monitoring Blocking Calls |
| Talking Bytes across a Socket Connection |
| Using the Non-Blocking Calls |
| Exceptions |
| Additional Samples - Chat |
| Creating COM Components |
| Reference Counting |
| Marshalling |
| Type-library Marshalling |
| Standard Marshalling |
| Dolphins COM Framework |
| Interfaces |
| Implementations |
| COMObjectStub |
| Class Factories |
| Building a COM component |
| Write or Acquire IDL |
| Build Type Library |
| Generate Interfaces |
| Define Implementation Class |
| Testing & Debugging |
| Debugging with Dolphins COM Framework |
| Client Limitation |
| Debugging "In-image" |
| Registering a Class Factory |
| Choice of Client |
| Registering the Component |
| Registering the Marshalling Code |
| Debugging In-Process |
| The Image Key |
| In-process Start Up Sequence |
| Initiating an In-process Debugging Session |
| Terminating an In-Process Session |
| Debugging Out-of-Process |
| Out-of-process Start Up Sequence |
| Creating an Instance |
| Initiating an Out-of-Process Session |
| Pre-started Session |
| On Demand Session |
| Terminating an Out-of-Process Session |
| Failure to Shutdown |
| Deploying & Running the Random Stream Sample |
| Step 1 Deploy |
| Step 2 Test (Unregistered) |
| Step 3 Register |
| Step 4 Test (Registered) |
| Step 5 Register Type Library (Windows 9x only) |
| Bibliography |
| DolphinSure |
| Redistributables |
| DolphinSure Certificates |
| The CA Root Certificate |
| Company Certificates |
| Personal Certificates |
| Applying for a DolphinSure Certificate |
| DolphinSure Certificate Stores |
| My Certificates |
| Temporary Trust |
| Permanent Trust |
| Installing a Certificate |
| Accessing the Stores |
| Creating your own Trusted Data |
| Tutorials |
| A First Splash with Dolphin |
| With the examples below: |
| 3+4 |
| Big Numbers |
| Timing Things |
| Sorting and Inspecting Things |
| How Many Objects? |
| Digital Clock |
| Stop the Clock |
| Play a Sound |
| Initialising an Array |
| Win the Lottery |
| Win the Lottery (Reprise) |
| Scribble |
| Sketching and Scribbling at the Same Time |
| Searching the Image for Text |
| Tidying up |
| When You've Finished Here... |
| Beginners Guide to Smalltalk |
| Getting Started |
| First Use |
| Opening a new Workspace |
| Exiting Dolphin |
| The Image |
| When should I save my Image? |
| The System Folder |
| The System Transcript |
| What have you learned? |
| Objects and Messages |
| What is an Object? |
| Objects communicate with Messages |
| Simple Messages |
| Messages that are not understood |
| Sending Messages on top of Messages |
| Binary Messages |
| Keyword Messages |
| Comments |
| Arithmetic |
| Order of Messages |
| Variables and Assignments |
| Workspace Variables |
| Temporary Variables |
| Instance Variables |
| Global Variables |
| Cascading Messages |
| Yourself |
| Message Selectors are Symbols |
| What have you learned? |
| Playing with Objects in the Playground |
| Creating a Playground |
| Adding Shapes to a Playground |
| Talking to Teresa, Simon and Charlie |
| Making them Jump |
| Experimenting |
| What have you learned? |
| Control Flow |
| Setting up a Playground for Experimentation |
| Comparing Objects |
| Testing an Object |
| Controlling the Flow of Execution |
| Looping |
| Iterating Through a Range of Values |
| More Complicated Boolean Expressions |
| The Beauty of #ifTrue: (and friends) |
| What have you learned? |
| Classes and Methods |
| Classes |
| Class Browser |
| Methods |
| Short is beautiful |
| Method header |
| Temporary variables |
| Answering a result |
| Private Methods |
| Named Instance Variables |
| Accessor Methods |
| Categorizing Methods |
| Indexed Instance Variables |
| Classes as Object Factories |
| Getting More Help on the Class Browser |
| What have you learned? |
| Programming in Smalltalk |
| The Animal game |
| How it works |
| Class Inheritance |
| Superclass and subclass |
| Is-a and Contains-a Relationships |
| Creating a class |
| Adding instance variables |
| Adding methods |
| Adding accessor methods |
| Time for a Test |
| Nil |
| Instance creation methods |
| Representing an object as text |
| #displayString and #displayOn: |
| #printString and #printOn: |
| Self and Super |
| Creating the Question class |
| Add class Question as a subclass of Object |
| Add the accessor methods |
| Adding an instance creation method |
| Printing and displaying a Question |
| Creating a class variable to hold the knowledge base |
| Initialize the Animal class |
| Wiring the game together |
| Asking the questions |
| Prompting for a new Animal |
| Prompting for a new Question |
| Playing the game |
| Emergency checklist |
| Packaging the Animal game |
| Creating a new package |
| Creating a package comment |
| Saving the package |
| Unloading a package from your image |
| What have you learned? |
| Tell Me How |
| Creating a GUI Application |
| Using Patterns |
| PersonalMoney - a simple account manager |
| Creating a Project |
| Designing the Domain Models |
| PersonalMoney |
| PersonalAccount |
| PersonalAccountTransaction |
| Testing the Domain Models |
| Designing the User Interface |
| PersonalAccountShell: a Presenter for PersonalAccount |
| Drawing a View for PersonalAccountShell |
| Using the Property Inspector |
| Adding the fields |
| Adding static decoration |
| Adding Command Push Buttons |
| Menus and Toolbars |
| Saving the View |
| Testing the User Interface for PersonalAccount |
| PersonalAccountTransactionDialog:a Presenter for PersonalAccountTransaction |
| Drawing a View for PersonalAccountTransactionDialog |
| Saving the View |
| Testing the User Interface for PersonalAccountTransactionDialog |
| PersonalMoneyShell: a Presenter for PersonalMoney |
| Drawing a View for PersonalMoneyShell |
| Saving the View |
| Testing the PersonalMoney application |
| The PersonalMoney application in use |
| Appendix A: Jumping Into Smalltalk |
| Temporary Variables |
| Assignment |
| Messages |
| Statements |
| Literals |
| Special Words |
| Returning from Methods |
| Cascades |
| Comments |
| Instance Creation |
| Constructors |
| Methods |
| Blocks |
| End of the Syntax |
| Control Structures |
| Loops |
| Things Left To Learn |
| Appendix B: Dolphin Pattern Book |
| Software Patterns |
| The Pattern Sheet |
| Further Reading |
| Application Patterns |
| New Application |
| Class Patterns |
| New Class |
| Class Name |
| Instance Variable Role |
| Instance Variable Name |
| Class Initialization |
| Abstract Class |
| Abstract Factory |
| Process Safe Class |
| Property |
| Method Patterns |
| New Method |
| Method Name |
| Temporary Variable Role |
| Instance Creation Method |
| Instance Initialization |
| Lazy Initialization |
| Accessor Method |
| Factory Method |
| Constant Access Method |
| Private Method |
| Code Layout |
| Method Comment |
| Global Variable Patterns |
| Global Variable |
| Global Name |
| Singleton |
| Object Lifetime Patterns |
| Finalization |
| Weak Collection |
| Object Liberation Strategy |
| External Interfacing Patterns |
| External Library |
| External Method Selector |
| External Callback |
| Miscellaneous Patterns |
| Inheritance vs. Composition |
| Policy |
| Word Capitalization |
| Glossary of Terms |
© 1997 - 2006 by Object Arts Ltd, all rights reserved