VA Smalltalk Videos

 
 

Categories:

VA Smalltalk Tools / Environment - standard development time tooling

ENVY - code management

Debugging - examining live code for purposes of understanding behavior or removing defects

WindowBuilder - WYSIWYG user interface builder

Composition Editor - visual code development via visual and non-visual parts

Trailblazer - alternative to standard development time tooling

VA Smalltalk Class Libraries - Smalltalk classes that are part of the shipped code repository

Database - support for Oracle, DB2 and Common Language Interface

GLORP - (Generic Lightweight Object-Relational Persistence) support for the open-source object-relational mapping layer for Smalltalk.

Test / SUnit - code testing

Log4s - framework to log code execution

HTTP / Web -support for client-server applications using HTTP, XML to communicate over intranet or internet

Seaside - support for the open source web application framework for developing web applications

Command Line - control of Smalltalk environment accessible at startup

Goodies - community application contributions



VA Smalltalk Tools / Environment
ST 4U 68: Save and Start a New VA Image

Once you've started the base VA Image, you probably don't want to have to reconnect to ENVY on each start. Today we'll save a VA image, then set up a desktop shortcut (Windows) to start up that saved image.

ST 4U 72: Exploring VA Smalltalk

James Robertson. One of the things I like to do with a system I'm not terribly familiar with is start from something I do know, and explore from there.

ST 4U 75: Modify the Fonts Used in VA Smalltalk

Don't like the font that VA picked when it started up? It's easy to modify the one used by the various tools, and today we'll look at how you do that..

ST 4U 77: The VA Workspace

Today we take an overview look at the VA Smalltalk workspace tool.

ST 4U 79: Exploring the VA Inspector

Today we take a look at the inspector tool in VA Smalltalk.

ST 4U 103: Online Help for VA Smalltalk

WindowBuilder Pro is one of two ways to build a user interface in VA.

ST 4U 105: Using the Refactoring Browser in VA Smalltalk

If you're coming to VA Smalltalk from a different dialect the refactoring browser may already be familiar to you; today we'll look at using this tool in VA Smalltalk instead of the standard browser or the Trailblazer variant.

ST 4U 136: Code Completion in VA 8.5

VA Smalltalk 8.5 adds code completion to the browsers; today we'll take a look at how that works.

ST 4U 138: Configuring Coding Assistance in VA Smalltalk

The new auto completion feature of VA Smalltalk 8.5 isn't delivered "as is" - you can configure various aspects of how it operates.

ST 4U 139: VA System Settings

Take a look at anumber of configurable settings for the VA Smalltalk system.

ST 4U 173: VA Asist Pro

Today we'll look at some of the code checking features that VA Assist Pro adds to VA Smalltalk. It's now a standard part of the toolset, so you should have a look.

ST 4U 191: Generating Accessors in VA Smalltalk   

Using the default browsers in VA Smalltalk, it doesn't look like you can generate accessing methods for instance variables. Never fear though - Trailblazer adds that for you.

ST 4U 204: Changing the Fonts in VA Smalltalk  

Today we'll look at how easy it is to change the default font used acrosss all VA Smalltalk tools.

ST 4U 216: Screenshots Within VA Smalltalk 

You often need to take screencaps when doing software development. VA has tools for that right in the image.

ST 4U 231: Code Completion in VA 8.5.1

Instantiations has really improved the code completion support in VA 8.5.1; today we'll look at some of that.

ST 4U 236: VA Assist Pro

Today we'll take a look at some of the configurable options for VA Assist Pro.

ST 4U 237: VA Assist Pro Settings

Today we'll take a look at how to save and restore your VA Assist Pro settings.

ST 4U 259: Inspectors in VA Smalltalk

Today we'll take an overview look at inspectors in VA Smalltalk.

ST 4U 265: SmallLint in VA Smalltalk

There's a feature set called "Mastering Envy Developer" in VA Smalltalk, and one of the interesting things it loads is Small Lint. Today we'll look at what kinds of issues in code it can help turn up.

ST 4U 266: Rewrite Tool Transformations

The rewrite engine exists in every major Smalltalk dialect - tody we'll start looking at how to use it in VA Smalltalk.

ST 4U 273: Configuring VA Toolbars

In VA Smalltalk, the toolbars are easily configured. Today we'll see just how easy that is.

ST 4U 278: Comparing Editions in VA Smalltalk

While any version control system will let you cpmpare packages, ENVY takes that one step further - since it tracks everything, you can compare against editions you never formally published.

ST 4U 280: Less Common Config Options in VA Smalltalk

It turns out that there are a number of less used (but possibly quite valuable at times) configuration options in VA Smalltalk. Today we'll take a brief look at some of them.

ST 4U 281: Less Common Config Options in VA Smalltalk (2)

Today we'll continue with the preferences workspace, looking at how you can change the file out format. That can be valuable for open source projects that need to move code between Smalltalk dialects.

ST 4U 297: Inspecting any Object in VA Smalltalk

In VA Smalltalk, there are tools built in to make it easy to inspect any visible object on the screen. Today we'll take a look at that.

ST 4U 300: Recently Visited in VA Smalltalk

One of the nice little touches in VA Smalltalk is the "recently visited" menu off the launcher in options.

ST 4U 301: Benchmarking Tools in VA Smalltalk

Today we'll introduce the basic benchmarking tools available in VA Smalltalk.

ST 4U 303: Using the VA Smalltalk Benchmark Tool

Today we'll take an overview look at using the VA Smalltalk benchmarking tools.

ST 4U 304: VA Smalltalk Benchmarking Options

Today we'll go more in depth on the VA Smalltalk benchmarking tools.

ST 4U 306: More VA Benchmark Tool Overview

Today we'll take one last look at the VA benchmarking tool, covering a few things we missed along the way.

ST 4U 307: Pinpoint Benchmarking

Sometimes, you need to measure at a much more fine grained level than the benchmarking tools get to. For that, you can easily record the time it takes to run a segment of code.

ST 4U 309: Code Abbreviations in VA Smalltalk

In addition to code completion support, VA also supports editable abbreviations. We'll take a look at that today.

ST 4U 327: Memory Monitoring in VA Smalltalk

VA Smalltalk provides some tools for examining memory use in your image - today we'll start taking a look at them.

ST 4U 363: EmSystemConfiguration in VA

There are a number of handy APIs in the class EmSystemConfiguration, accessible via the System variable.

ST 4U 440: Code Assistance Extended in VA 8.5.2

Today we'll start looking at some of what's new in VA Smalltalk 8.5.2 - starting with code assistance in the inspector.

ST 4U 446: Monticello Importer in VA Smalltalk

In VA ST 8.5.2, the importer moved from the goodies into the base product - a component you can load straight from Envy. We'll have a brief look at it today, along with things you'll need to look out for when using it.

ST 4U 475: Using the Monticello Importer

Today we'll use the Monticello importer to bring a small package in from Pharo - and show you the sorts of issues you'll still have to deal with once you have the code loaded into VAST.

ST 4U 481: The VA 8.6 Environment Launcher

A few releases ago, VisualWorks added a launcher tool to help developers manage images without having to do so much manual labor. Now the same kind of tool has arrived for VA - we'll have a look at it today.

ST 4U 484: More on the VA Environment Tool

Today we'll take a closer look a the the new environment launcher for VA Smalltalk 8.6, examining all of the options it provides.

ST 4U 487: Undo and Redo in VA 8.6

One of the nice things about getting Scintillate as the editor in VA Smalltalk is the addition of multiple undo/redo.

ST 4U 490: Unknowns in the VA Editor

The VA Smalltalk editor (based on Scintilla) now takes note of unknown references and flags them (by default with red squiggly lines, as Word does). This seems like a small thing, but it's highly useful.

ST 4U 493: Color Syntax Customization in VA

The color syntax highlighting in VA Smalltalk is customizable - and since the new Scintilla-based editor is fast, you can tweak it to your heart's content.

ST 4U 496: Configuring Editor Feedback in VA 8.6

You can configure virtually all of the feedback from the new Scintillate-based editor (and the incremental compiler) in VA Smalltalk 8.6. Code Assist uses the Scinitllate editor on the Windows platofrm. Today we'll have a look at the options for configuring Code Assist. ST 4U 499 shows additional options.

ST 4U 532: Getting Help for VA Smalltalk

If you have a problem that you aren't ready to go to support for, but would still like advice on, what do you do? Check out the VA Smalltalk forums, that's what.

ST 4U 535: Application Visibility in VA

You can change the visibility level of classes that are in, and related (by prerequisite) to a given application easily. Today we'll have a look.

ST 4U 538: Basic VA Smalltalk Usage - Part 1 , ST 4U 541: Part 2 and ST 4U 544: Part 3

In part 1 we'll walk through some basic VA Smalltalk usage - creating an application, and then creating a class in that application... and then in part 2 we'll recover the application we didn't version in part 1 and release it. Finally, in part 3 we'll properly version our application in Envy so that reloading it won't require so many steps.

ST 4U 547: Basic VA Smalltalk Usage - Part 4

Today we'll extend an existing class in VA Smalltalk without modifying the application that defines that existing class. We'll version and use that method within our own Application. This series continues with ST 4U 550.

ST 4U 553: Basic VA Usage - Part 6 , Part 7

This series continues from ST 4U 550. In part 6 we'll start adding a new TestCase subclass to our application - which requires a few interactions with Envy first. In part 7 we'll create a test case for our simple counter app, and explain how test cases are exercised in VAST.

Back to top


ENVY
ST 4U 69: Create a New ENVY User

When you start using VA, you shouldn't save your work as the Library SUpervisor. Instead, create a new ENVY user and work as that user.

ST 4U 84: Recovering Code in ENVY

With ENVY in VA Smalltalk, all of the work you do is being tracked by the source code system. If you quit an image without saving your work, it's very easy to get it all back in the same form that you left it. Today we'll look at that process as part of an introduction to how ENVY works.

ST 4U 85: Releasing a Version into ENVY

Today we look at taking an application in VA Smalltalk and releasing it to ENVY as a formal version.

ST 4U 92: Creating a Configuration Map in VA

This video shows how to create a configuration map.

ST 4U 95: Specifying Configuration Map Pre-Reqs

We created a configuration map to hold a simple counter application and the associated application for the tests - but we didn't set it up to pre-load SUnit if it's not in the image already. Today we take care of that.

ST 4U 132: Creating a New Edition in VA Smalltalk

If you start working in a released application in VA Smalltalk, you'll get prompted about creating a scratch edition. Today we'll go into how you manage the creation of an open edition of an application (that you can work in).

ST 4U 135: Exporting and Importing Code with ENVY 

When migrating from one version of VA Smalltalk to another, you need to take your code (as opposed to the system code) along with you. Today we'll export the Seaside tutorial code from VA Smalltalk 8.0.3 and import it into VA Smalltalk 8.5).

ST 4U 174: Cloning an ENVY Repository

If you need to make a replica of your ENVY repository, VA provides a simple way to do that. We'll take a look at it today.

ST 4U 203: Scratch Editions in Envy 

If you just start coding without first "opening" a new edition in VA Smalltalk, you get a scary sounding warning. Today we look at how it's not actually very scary.

ST 4U 234: ENVY Config Maps

Today we'll take a look at the various properties of an ENVY configuration map, and how you might use them.

ST 4U 235: Config Maps and the Development Process

Today we'll take a look at the normal development process in VA Smalltalk, using Configuration Maps, Applications, and open editions.

ST 4U 239: Finding Open Editions

Using the normal development process in VA Smalltalk, you'll have open editions of classes quite frequently. Today we'll look at how to figure out what you do have open.

ST 4U 242: Applications and Subapplications in VA Smalltalk

Today we'll take a look at Subapplications in VA Smalltalk - how they are used in the system as it's shipped, and why you might want to use them yourself.

ST 4U 243: Extending a Class in VA Smalltalk

In VA Smalltalk, the definition of a class is owned by a specific application. You can, however, extend a class (with new methods) in a different application.

ST 4U 257: Code Recovery in VA Smalltalk

In VA, you have ENVY - which makes code recovery a lot easier than sorting through the changes files as you do in most other Smalltalks. We'll take a look at that today.

ST 4U 298: Backing up Your Envy Repository

The good thing about VA Smalltalk is that ENVY saves everything. The downside is that you get a possible single point of failure. Fortunately, cloning your library is safe and easy to do.

ST 4U 369: Extending a Class in VA

Today we'll look at how to extend a class in VA Smalltalk (from the standpoint of Envy, not from the simple "add the method" point of view).

Back to top


Debugging

ST 4U 80: VA Smalltalk Debugger Overview

Today we take a quick tour of the VA debugger. This is an overview; we'll be taking a more detailed look in other screencasts.

ST 4U 81: Using Breakpoints in VA

To debug applications, you need to be able to set breakpoints, possibly with some conditional logic. Today we'll start taking a look at breakpoints, how to set them up, and how to use the debugger after hitting one.

ST 4U 87: Debug Any Process in VA Smalltalk

The VA Debugger has a nice little feature that lets you grab any process and haul it into the debugger. This morning we'll take a look at how that might be useful.

ST 4U 88: Another Route to the VA Debugger

If you look at the lower right hand corner of the screen when you have a VA image open, you'll see an access point into the debugger. Today we'll explore that.

ST 4U 272: Finding Breakpoints

Sometimes in Development, you add a lot of breakpoints. Later, you'll forget where they all are. Using VA Smalltalk, it's easy to round all of them up.

ST 4U 312: Finding all the Breakpoints

During development in Smalltalk, it's common to drop a lot of breakpoints. Fortunately, VA Smalltalk makes it easy to find, configure, and remove all of them.

ST 4U 550: Basic VA Usage 5

Today we'll walk through a simple use of the debugger to solve a problem. (this is the continuation of a series of videso begun with ST 4U 538.)

Back to top


Window Builder
ST 4U 106: Getting Started With WindowBuilder Pro

WindowBuilder Pro is one of two ways to build a user interface in VA

ST 4U 108: Finishing the CounterView UI in WB Pro

Today we complete the CounterView UI we built in the last tutorial, hooking it up to the domain object that we built earlier.

ST 4U 230: Using OCX Controls in WindowBuilder

We looked at using OCX controls in the VA Composition Editor; today we'll do the same thing in WB Pro.

ST 4U 456: Installing WindowBuilder Pro

WB Pro is one of the nicer tools in VA Smalltalk - today, we'll have a look at getting it set up in our image. You can get WB Pro from the downloads page.

ST 4U 460: Intro to WindowBuilder Pro

Today we'll look at some of the high level features of WB Pro in VA Smalltalk.

ST 4U 466: WindowBuilder Pro Basics

Today we are back to WindowBuilder Pro, having a look at how you use it to paint widgets onto a canvas.

ST 4U 469: A First WB Pro Application

Today we'll build a simple WB Pro UI, hook up a button event, and have a look at the results.

ST 4U 472: List Widgets in WB Pro

Today we'll build a very basic "master/detail" type of application using WIndowBuilder Pro in VA Smalltalk.

ST 4U 478: Connecting Widgets in WB Pro

Today we'll build a simple application in WB Pro where we connect two widgets in the gui builder.

ST 4U 502: OLE Controls in WB Pro

Today we'll use WindowBuilder Pro to add an OLE control to a new interface.

ST 4U 505: Settings Options for WindowBuilder Pro

WB pro has a number of settings, from the banal (default colors for widgets) to the complex (whether and how to generate code support). Today we'll look at some of the options that are available to you.

ST 4U 511: Positioning Widgets

Today we'll have a look at widget positioning in WindowBuilder Pro.

ST 4U 514: Other Widgets in WindowBuilder Pro

The list of widgets you can use in WindowBuider Pro is pretty big; today we have a look at the "other" category.

ST 4U 517: Callbacks Editing in WindowBuilder Pro

Today we'll have a look at some of the callback options you can set up for widgets using WindowBuilder Pro.

ST 4U 529: WidgetKit Pro 

Today we'll take an overview look at the WidgetKit pro tools in VA Smalltalk, starting with how to get them loaded properly.

Back to top

Composition Editor

ST 4U 218: Creating a Non-Visual Part in VA Smalltalk  

Today we'll start taking a look at the Parts editing tools in VA Smalltalk, starting with a simple non-visual part.

ST 4U 219: Creating a Visual Part in VA Smalltalk  

Today we'll continue with the parts editor in VA Smalltalk, by hooking up a new visual part to our previously created non-visual part.

ST 4U 221: Limiting Your Connections Viewed  

Once you've built a more complex part in VA Smalltalk, the connections can get to be visually overwhelming. Fortunately, you can filter the view easily.

ST 4U 222: A Look Around the Composition Editor  

Today we'll step back from the example application, and take a look at some of the ways to make it easier to interact with the Composition Editor - starting with VA Assist Pro.

ST 4U 224: Getting Started With OLE Controls in VA Smalltalk 

Today we'll use a really simple OLE control - a simple image pane - to get started with OLE in VA Smalltalk.

ST 4U 225: Embedding a Windows Application in VA Smalltalk 

Today we'll use a really simple OLE control - a simple image pane - to get started with OLE in VA Smalltalk.

ST 4U 227: Launching an External Application in VA Smalltalk

Today we'll use the composition editor to hook up a VA window button to an external program - clicking the button will launch a browser.

ST 4U 228: Using OCX Controls in VA Smalltalk 

Today we'll use the composition editor to embed an OCX control into a VA Smalltalk window.

ST 4U 529: WidgetKit Pro 

Today we'll take an overview look at the WidgetKit pro tools in VA Smalltalk, starting with how to get them loaded properly.

Back to top


Trailblazer
ST 4U 98: Trailblazer Browsers

The default browsers in VA Smalltalk are not your only option - you can load the Trailblazer variants and get a different experience. You'll have to decide for yourself whether you like them better than the defaults, but they pack in a lot more information.

ST 4U 100: Exploring Trailblazer

A more in depth look at the Trailblazer tools in VA Smalltalk, focusing on the config maps view.

ST 4U 101: Exploring Editions with Trailblazer 

We continue our overview of the Trailblazer tools in VA Smalltalk, with a look at the Application Edition browser.

Back to top


VA Smalltalk Class Libraries
ST 4U 150: Exception Handling in VA Smalltalk

Today we'll look at handling exceptions in VA Smalltalk, using both the older Signal (instance based) mechanism, and using the newer ANSI (class based) system.

ST 4U 176: Exploring Class String

Today we'll start looking at some of the standard class libraries in VA Smalltalk, starting with String.

ST 4U 177: Opening Files in VA Smalltalk

Today we'll look at how to open files for reading and writing in VA Smalltalk.

ST 4U 179: Read Streams in Smalltalk

Today we'll look at using Streams to read data in VA Smalltalk.

ST 4U 180: Write Streams in Smalltalk

Today we'll look at using Streams to write data in VA Smalltalk.

ST 4U 182: Durations and Delays

In software development, you often need to run a timer - in order to wait a time interval to check a status, or do some task. In VA Smalltalk, you'll use Duration and Delay to get that done.

ST 4U 183: Blocks in Smalltalk

Today we'll take a look at Blocks (closures) in VA Smalltalk.

ST 4U 184: Processes in VA Smalltalk  

Today we'll look at the process model in VA Smalltalk. As with most Smalltalk, processes in VA are lightweight (green) threads.

ST 4U 186: Exploring The Smalltalk Process Model  

Today we'll take a deeper look at the process model in Smalltalk by way of a few examples. We'll have a look at the cooperative nature of that model, and how you can work within the framework.

ST 4U 198: Raising Exceptions in VA Smalltalk  

Need to raise an exception in VA Smalltalk? You can simply follow the ANSI spec and do it the same way you do in VW or Pharo.

ST 4U 200: A Case Statement in Smalltalk  

Ever had someone ask why Smalltalk doesn't have a case statement? While it's true that you don't need one, having an example is a pretty good way to show off the flexibility of the language.

ST 4U 201: Using the Case Statement in Smalltalk  

Today we take the example case statement we built last time, and put it through its paces.

ST 4U 229: Message Construction

Using string concatenation, symbols, and perform, you can dynamically create messages to send. This is a powerful, but risky capability in Smalltalk. Today we'll take a look at a simple example.

ST 4U 240: Making External API Calls

Today we'll take a look at how to make external API calls in VA Smalltalk.

ST 4U 246: Parsing XML in VA Smalltalk

Today we'll take a look at the parsing XML in VA - what to load, and how to get started.

ST 4U 247: SAX Parser Overview in VA Smalltalk

Today we'll take basic overview look at SAX parsers in VA Smalltalk.

ST 4U 252: Basic Socket Communications in VA

Today we'll set up basic socket communications, using VA as a client and VW as a server.

ST 4U 277: DDE in VA Smalltalk

While DDE is a venerable form of inter-process communication for Windows, it's still there, and works well in VA Smalltalk. Today we'll use a small example.

ST 4U 283: DoesNotUnderstand Abuse

When you first learn that you can override the way Smalltalk deals with a "Message Not Understood" exception, it tends to lead to seemingly cool code - but beware, that kind of cool code can make things very hard to figure out.

ST 4U 286: Interesting Collection Methods

Today we'll have a look at some of the more interesting collection protocol methods - we're using VA Smalltalk to illustrate, but most of the things covered here are applicable to all of the major Smalltalk implementations.

ST 4U 288: Using Files in VA Smalltalk

Today we'll take a look at some of the high level APIs for reading/writing files in VA Smalltalk.

ST 4U 289: Reading Binary FIles in VA Smalltalk

Need to read binary data in VA Smalltalk from a file? That's what we look at today.

ST 4U 291: Reading and Writing Binary FIles in VA Smalltalk

Today we'll go back to file IO in VA Smalltalk, and execute a simple example: write some data in binary mode, then read it back in.

ST 4U 292: Random Numbers in VA Smalltalk

Quite often, you need to generate random numbers in an application - today we'll see how in VA Smalltalk.

ST 4U 294: Custom Seeds for Random Numbers in VA Smalltalk

Most of the time, the default seeds will work fine in VA Smalltalk - but what if you need to plug in your own?

ST 4U 295: Large and Small Integers in VA Smalltalk

One of the nicer things about Smalltalk is the fact that you don't need to worry about "big int" when doing math. Today we'll have a look at that.

ST 4U 310: Unix Processes in VA Smalltalk

Today we'll take a look at the support for dealing with Unix/Linux processes in VA Smalltalk.

ST 4U 314: Reading Collections with Streams

Most of the time when we use streams, we read from files are strings. But in Smalltalk, you can read any collection with streams.

ST 4U 315: Writing Collections with Streams

Just as we can read any collection of objects with a stream, we can write them as well.

ST 4U 317: Dictionary Variance

The way class IdentityDictionary works in VA and Pharo differs from VW; today we'll look at how.

ST 4U 318: Sketching Out a CaseStatement Object

You mostly don't need a case statement in Smalltalk (that's what Polymorphism is for) - but today we'll sketch one out.

ST 4U 320: Using a CaseStatement in Smalltalk

Last time we looked at the idea of a case statement in Smalltalk, we asserted that you should really be using polymorphism. There are times when that's not the best answer; today we'll sketch that idea out some.

ST 4U 321: Using Polymorphism

Today we'll take a look at polymorphism in Smalltalk. Most of the time, when you think you need a case statement or a series of true/false checks, you really need polymorphic behavior.

ST 4U 323: More on Polymorphism

While we sketched out a simple example last time, today we need to take a look at what you'll face if you decide to add polymorphic coverage of something more substantial - say, Collection behavior.

ST 4U 234: Message Swallowing MNU

In Smalltalk, you can handle (or completely obscure) MessageNotUnderstood exceptions. While it 's quite cool the first time you see this, it's also pretty dangerous, and should not be done outside of a few specific applications.

ST 4U 325: Constructed Messages

While it can be useful to construct messages from strings, it's also risky - the tools in your image can't find the senders of the constructed message (thus making the implementations appear to be unused). This can have implications on packaging, and on understanding the application.

ST 4U 332: Bags and Sets

Today we'll take a look at Bags and Sets, two classes in the collection hierarchy that it's useful to understand.

ST 4U 333: Binary Object Storage in VA Smalltalk

Today we'll take a look at the ObjectDumper and ObjectLoader - which let you save objects out into a binary file, and load them back in.

ST 4U 351: Reflecting with instance variable names

Sometimes when you read data from an external source (files, XML, database), it can be useful to map names from the source to names in the Smalltalk code. Today we look at how that works.

ST 4U 354: Collections and Streams

You probably knew that Array objects are fixed size in Smalltalk. What you might not know is that there are various ways around that limitation.

ST 4U 359: Starting External Programs in VA Smalltalk - Part 1

It's easy enough to start an external application using the Composition Editor, but what about in Smalltalk code? Turns out that's easy too.

ST 4U 360: Starting External Programs in VA Smalltalk - Part 2

What if you need to send command line arguments to an external program yoi want to start up? No problem - VA makes that easy as well.

ST 4U 366: Errors and Exceptions in VA Smalltalk

Depending on what libraries you are using, you either need to handle exceptions or look for errors. Today we'll have a look at the difference.

ST 4U 372: GF ST in VA Smalltalk

Need to do some simple graphics in VA Smalltalk? GF/ST might suit your needs, and it's portable across dialects to boot.

ST 4U 375: Reading Image Files in VA Smalltalk

Need to read in an image (graphic) from a file in VA Smalltalk? Today we'll have a look at that.

ST 4U 378: Determining the Image File Format

Last time we looked at reading image files in VA Smalltalk - today, we'll look at how to determine what format the file is, so that we can use the correct reader on it.

ST 4U 382: Cobol Access in VA Smalltalk  

Using VA Smalltalk, you can access Cobol libraries - today's screencast does an overview of that.

ST 4U 387: Cascades and yourself

People new to Smalltalk often wonder why cascades usually end in #yourself. Today we'll look at why that is.

ST 4U 392: OLE Embedding in VA Smalltalk

Today we'll look at one of the example applications in VA Smalltalk, which shows you how to do OLE embedding (in code, as opposed to the UI tools).

ST 4U 396: Money in VA Smalltalk

When you deal with monetary amounts in software, you should not use Floating point numbers. Today we'll look at the money object in VA Smalltalk.

ST 4U 401: Bad Choices with DNU

One of the things you can do in Smalltalk is use #perform: with message construction to get yourself into trouble. Today we'll look at a very egregious example of what not to do.

ST 4U 451: Timezones in VA Smalltalk

VA 8.5.2 introduces Timezone sipport - today we'll look at two deprecated methods you need to pay attention to when upgrading.

ST 4U 508: Dictionaries in VA Smalltalk

In VA Smalltalk, there's a dictionary subclass that's been set up to handle large data sets (i.e.e, avoid collisions in hashing). Today we'll have a look.

ST 4U 526: HLLAPI Support in VA Smalltalk

Today we'll take an overview of the HLLAPI support in VA Smalltalk.

Back to top


Database

ST 4U 140: Connecting to a Database with VA Smalltalk

Today we'll take a look at the basics of talking to a relational database using VA Smalltalk - what to load, and how to establish a connection.

ST 4U 142: Using SQL in VA Smalltalk

Today we'll start looking at using SQL with VA Smalltalk against a relational database. To start with, we'll create a simple table and ensure that the table is, in fact, created.

ST 4U 143: Insert and Query in VA Smalltalk

Today we'll look at inserting data into, and querying data from databases in VA Smalltalk.

ST 4U 144: Updating Rows in a Database using VA Smalltalk

Today we'll look at updating rows in a database using VA Smalltalk.

ST 4U 146: Deleting from a Table using VA Smalltalk

Today we'll look at deletig data from a database using the object level interface in VA Smalltalk. We'll get to a more direct SQL approach soon.

ST 4U 147: Using SQL Directly with VA Smalltalk

Usually, it's more optimal to deal with a database natively using SQL. Today we'll look at how you do that in VA Smalltalk with query specifications.

ST 4U 149: Parameterized Statements in VA Smalltalk

When inserting or updating tables, it's useful to map objects you have to a table. Today we'll look at how to do that in VA Smalltalk.

ST 4U 153: Handling Database Framework Errors in VA Smalltalk

It can be useful to set up a "catchall" exception handler for database related problems, and that's easy to do in VA Smalltalk. Today we look at how that's done.

ST 4U 154: Empty Query Results in VA Smalltalk

How can you tell whether your query returned no rows in VA Smalltalk? Simple, use standard collection protocol.

Back to top


GLORP

ST 4U 155: Loading GLORP Support in VA

Today we'll get started with GLORP for VA Smalltalk by loading it into our image.

ST 4U 156: Setting up GLORP for Oracle in VA Smalltalk

Today we'll take a look at setting up connectivity for GLORP and Oracle in VA Smalltalk.

ST 4U 158: Getting Started with GLORP in VA

Today we'll walk through the basic login setup using GLORP and Oracle with VA Smalltalk

ST 4U 159: Setting up a GLORP Descriptor

Today we'll define a GLORP descriptor so that we can start mapping a domain class to the database - and we'll illustrate the usage by creating a table with that descriptor

ST 4U 162: Using a Glorp Descriptor

Today we'll start using the Glorp descriptor we created last time, to insert and query data.

ST 4U 163: Constructing Queries with Glorp

oday we'll use the simple Emp class (and table) we created in Oracle, and construct a few simple queries against it.

ST 4U 164: Deleting from a Database with Glorp

Today we'll look at how you delete from a database using Glorp, but - our example isn't going to work. Why? Because when we defined the simple example, we didn't specify a primary key. As we'll see, that's essential when using Glorp.

ST 4U 167: Deleting with Glorp

Today we'll specify a primary key in our table mapping, and then show how to delete from a database table using that information.

ST 4U 168: Using Transactions with GLORP

When we deleted a row from the database in our last screencast, we implicitly used a transaction. Today we'll look at how you explicitly do commits or rollbacks.

ST 4U 169: Refreshing an Object with GLORP

Some applications need to make sure that they have the latest version of an object from the database - other processes (or users) might be modifying the same data. Today we'll look at how you handle that with Glorp.

ST 4U 170: Using Sequence Numbers with Glorp

Today we'll drop the table we've been using, modify the definition to include a proper primary key, and add it back. We'll then add some data to it, and have a look at what happened. That'll cover sequence generators, and dropping tables using Glorp.

Back to top


Test / SUnit
ST 4U 90: Test Driven Development in VA Smalltalk

SUnit is the standard way to do unit testing - and thus, test driven development - across all the Smalltalk dialects. Today we take a look at doing TDD in VA Smalltalk.

ST 4U 91: Focusing SUnit on Specific Tests

Today we look at focusing the SUnit browser in VA Smalltalk on a specific set of tests, instead of on every test in the system. If you have a large project with many tests (like, say, Seaside) loaded, this is invaluable.

Back to top


Log4s
ST 4U 206: Introducing Log4s  

Today we'll start looking at log4s (a logging framework) in VA Smalltalk.

ST 4U 207: Using log4s in VA Smalltalk  

Today we'll continue with log4s, looking at how to set up a new appender (logging stream) on an already configured logger.

ST 4U 209: Creating a new Logger with log4s 

Need to have separate loggers to track different applications/parts of applications? Log4s makes that easy.

ST 4U 210: Filtering Logs by Level 

Today we'll look at coarse grained filtering in log4s - specifying different logging levels for appenders on the same logger.

ST 4U 212: Customizing log4s output 

Today's screencast looks at how you can customize the output of log4s data via the built in pattern specifiers - and the support code that you can implement to make use of it.

ST 4U 213: Useful log4s APIs 

Today we'll wrap up our look at log4s in VA Smalltalk with an examination of some of the useful APIs that we've brushed over in the other screencasts on log4s.

Back to top


HTTP / Web
ST 4U 192: Http Get in VA Smalltalk  

Need to do HTTP queries inn VA Smalltalk> Today we'll look at that.

ST 4U 194: HTTP Queries in VA Smalltalk 

Last time we looked at setting up HTTP queries in VA Smalltalk. Today we look at asimpler way to go about that, and also take a look at proxy server usage.

ST 4U 195: URL encode/decode in VA Smalltalk  

Encoding and decoding text is something you need to do quite frequently when doing web related development; today we look at the support for that in VA.

ST 4U 197: A Simple HTTP Server in VA Smalltalk  

Need a simple HTTP server in VA Smalltalk? Today we'll set up a simple one.

ST 4U 248: Using a SAX Handler in VA Smalltalk 

Today we'll go a little more in depth, and take a look at one of the SAX examples that ship with VA Smalltalk.

ST 4U 249: DOMs and DTDs in VA Smalltalk 

Today we'll take a look at another VA Smalltalk example, using an XML document and a DTD.

ST 4U 251: Mapping XML to Objects in VA 

By adding a mapping XML specification, you can have the VA parser read your XML file and answer a collection of objects.

ST 4U 254: A Simple Socket Server in VA Smalltalk 

Today we'll flip our example around - VA will listen, and VW will send data over.

ST 4U 268: Getting Started with Web Services in VA Smalltalk 

Today we'll start looking at WS* support in VA Smalltalk - starting with what to load, and where the examples in the system reside.

ST 4U 269: Creating a Web Service in VA Smalltalk 

Today we'll take the first few steps required to create a web service in VA Smalltalk.

ST 4U 274: Examining the WS* XML Files in VA 

Today we'll take a somewhat more detailed look at the XML files that get generated by the VA WS* codebase for a simple example.

ST 4U 275: Using Web Services in VA Smalltalk 

Today we'll put all of the peices together - we'll deploy and invoke a VA Web Service.

ST 4U 520: SST HTTP Example 

Today we'll take a look at the HTTP server support in VA Smalltalk, using one of the built on examples as a starting point.

ST 4U 523: Servlets in Server Smalltalk 

Today we'll take a look at how servlets operate using the HTTP server in VA Smalltalk's server Smalltalk implementation.

Back to top


Seaside
ST 4U 112: A Domain Model for the Seaside Tutorial

Today we'll look at a simple domain model for use in the Seaside project we are building for this tutorial: a simple blog server in VA Smalltalk.

ST 4U 113: Building Our First Component in Seaside

Today we build the initial component for the seaside tutorial - what will eventually be the top page for the Seaside app.

ST 4U 115: Rendering Components

Today we add rendering to some of our sub-components, so that individual posts start showing in our main Seaside display.

ST 4U 116: Adding the Menu Component

Today we add the menu component to our Seaside blog application. We'll be adding filters, which will also involve getting the menu component to render, and a short discussion of the #children method in WAComponent.

ST 4U 118: Custom Sessions in Seaside

Today we add a custom session to our Seaside app, and configure the application to use it.

ST 4U 120: Flow in a VA Seaside App

The big difference between Seaside in VA and Seaside elsewhere is the lack of full continuation support. That's less of a problem than you might think - but it does mean that you need to adapt the various example you see online for VA. Today, we'll take a look at that using the Login UI we set up last time..

Back to top


Command Line
ST 4U 188: VA Smalltalk Command Line Options  

Today we'll take a look at some of the command line options available for VA Smalltalk - and show you where to go fo all the details.

ST 4U 189: Reading the Command Line in VA Smalltalk  

What if you need to add your own application level command line options using VA Smalltalk - how do you process them? Today we'll take a look.

Back to top


Goodies
ST 4U 285: Getting Started with VAST Goodies

The VAStGoodies.com site is a useful repository of code, provided by the VA Smalltalk community. It's also a nice example of a VA Smalltalk powered Seaside application.

If you're interested in using the VAStGoodies.com site, you don't need to load the tools from the website into ENVY; the folks at Instantiations have made it easier on you than that. The tools come with the shipped repository; you just need to load the feature and open a fresh configuration maps browser to import code from VAStGoodies.com.

ST 4U 97: Publishing to VAStGoodies.com

The tools we loaded into ENVY from VAStGoodies.com let you publish straight from your repository to the goodies site; today we'll take a look at that process, adding the CounterMap to the goodies repository.

ST 4U 339: Loading Code from a DAT File

This video could equally well be called "Getting started with VA Smalltalk Goodies." Goodies archives sample code and utilities provided by the Smalltalk community or IBM.

Many VA Smalltalk Goodies are made available as ENVY .DAT files; today we'll look at loading one (the tiny encryption app) as an example.

ST 4U 336: Additional Memory Tools for VA Smalltalk

A quick visit to the Instantiations goodies page for VA will get you some additional memory monitoring tools, Smalltalk memory consumption analysis.

ST 4U 342: Using XTea Encryption in VA.

XTEA is a simple encryption scheme, and there's a small goodie for VA that makes using it easy. If your needs for encryption are lightweight, it might be just what you are looking for.

Back to top

 

 

What’s New

Learn what's new in VA Smalltalk