Planet FoxPro

October 24, 2014

Alex Feldstein

Sandstorm's Blog (Home of ssClasses)

Easy ways to Capture images

I have not blogged for a long time and you guys know why.  Anyway, here is something that may be useful to you so I am making this entry here.  This is about FoxForm shared to us in Foxite Forum.  This combined with other things will allow us to easily capture our form, our app's screen and the desktop itself; with only few lines of codes.  In addition, you can send those captured images as well direct to printer.  Here are the steps:

  1. You have to download FoxForm in Foxite (you have to be a member).   Go to its download section and search for FoxForm (original codes written and submitted by Eric Den Doop).  Once downloaded, extract foxform.dll to your app's main folder and register it via going to CMD, going to your main app's folder and typing regsvr32 /foxform.dll.  You have to have an administrative right to register it.
  2. Once it is registered, here are some easy ways to capture things.  Anyway, let us declare some things first like ShellExecute()

Declare Integer ShellExecute In shell32.dll ;
      INTEGER hndWin, ;
      STRING cAction, ;
      STRING cFileName, ;
      STRING cParams, ;
      STRING cDir, ;
      INTEGER nShowWin

Okay we are on the go, let us start with capturing

Capture your active form

Local loTmp, HWnd, lcFile
loTmp = CREATEOBJECT("FoxForm.Form")
HWnd = _WhToHwnd(_wfindtitl(Thisform.Caption))
lcFile = Addbs(Getenv("TMP"))+Sys(3)+".bmp"
* Show the result outright

Capture your entire's app screen

Local loTmp, HWnd, lcFile
loTmp = CREATEOBJECT("FoxForm.Form")
HWnd = _WhToHwnd(_wfindtitl(_Screen.Caption))
lcFile = Addbs(Getenv("TMP"))+Sys(3)+".bmp"

There may be a chance that your app's screen is not on a maximized state, so if what you really wanted is to capture the entire screen without relying onto your app's WindowState?

Capture entire desktop screen

* Declare this first if not yet declared somewhere else
Declare Integer GetDesktopWindow In user32

LOCAL loTmp, hWnd, lcFile
loTmp = CREATEOBJECT("FoxForm.Form")
hWnd = GetDeskTopWindow()
lcFile = ADDBS(GETENV("TMP"))+SYS(3)+".bmp"

And finally, here is how you can send the result direct to printer instead of into a file

Capture Desktop and Print

Declare Integer GetDesktopWindow In user32

LOCAL loTmp, hWnd
loTmp = CREATEOBJECT("FoxForm.Form")
hWnd = GetDeskTopWindow()

Although we can likewise use ShellExecute() for that

Declare Integer GetDesktopWindow In user32

LOCAL loTmp, hWnd, lcFile
loTmp = CREATEOBJECT("FoxForm.Form")
hWnd = GetDeskTopWindow()
lcFile = ADDBS(GETENV("TMP"))+SYS(3)+".bmp"

The first one though allows us to send to the printer direct while the 2nd one using ShellExecute() requires us to save the result first onto a file then later send to printer.

When I found the original codes inside Foxite, it uses Foxtools.fll.  But when I tried it here, it works without it.  In case it do not work properly on your end though, then you have to add this line on top



by Jun Tangunan ( at October 24, 2014 01:47 AM

October 23, 2014

Kevin Ragsdale's FoxPro Blog

I Need Some SUBSTR() Help, Please!

Last week, I presented a session titled, “Unicode Made Easier with SQLite” at the Southwest Fox 2014 conference. At the end of the session, an attendee asked about manipulating strings, specifically using SUBSTR() on UTF-8 encoded strings. Last night, I played around with creating my own SUBSTR() function to deal with UTF-8 encoded strings, and […]

The post I Need Some SUBSTR() Help, Please! appeared first on Kevin Ragsdale.

by Kevin Ragsdale at October 23, 2014 01:16 PM

Alex Feldstein

October 22, 2014

Alex Feldstein

The incomparable Tommy Emmanuel at Woodsongs

Tommy Emmanuel’s appearance at the Woodsongs radio show showing his amazing talent.


by Alex Feldstein ( at October 22, 2014 09:18 AM

October 21, 2014

Alex Feldstein

Photo of the Day

South Pointe Park - At the tip of Miami Beach - (2-shot pano)

by Alex Feldstein ( at October 21, 2014 05:00 AM

October 20, 2014

Rick Strahl's Web Log

A jquery-watch Plug-in for watching CSS styles and Attributes

webmonitorlogo_smallerA few years back I wrote a small jQuery plug-in used for monitoring changes to CSS styles of a DOM element. The plug-in allows for monitoring CSS styles and Attributes on an element and then getting notified if the monitored CSS style changed. This can be useful to sync up to objects or to take action when certain conditions are true after an element update.

The original plug-in worked, but was based on old APIs that have now been deprecated in some browsers. There’s always been a fallback to a very inefficient polling mechanism and that’s what unfortunately had now become the most common behavior.  Additionally some jQuery changes after 1.8.3 removed some browser detection features (don’t ask!) and that actually broke the code. In short the old plug-in – while working – was in serious need of an update. I needed to fix this plug-in for my own use as well as for reports from a few others using the code from the previous post.

As a result I spent a few hours today updating the plug-in and creating a new version of the jquery-watch plug-in. In the process I added a few features like the ability to monitor Attributes as well as CSS styles and moving the code over to a GitHub repository along with some better documentation and of course it now works with newer APIs that are supported by most browsers.

You can check out the code online at:

Here’s more about how the plug-in works and the underlying MutationObserver API it now uses.

MutationObserver to the Rescue

In the original plug-in I used DOMAttrModified and onpropertychange to detect changes. DOMAttrModified looked promising at the time and Mozilla had it implemented in Mozilla browsers. The API was supposed to become more widely used, and instead the individual DOM mutation events became marked as obsolete – it never worked in WebKit. Likewise Internet Explorer had onpropertychange forever in old versions of IE. However, with the advent of IE 9 and later onpropertychange disappeared from Standards mode and is no longer available.

Luckily though there’s now a more general purpose API using the MutationObserver object which brings together the functionality of a number of the older mutation events in a single API that can be hooked up to an element. Current versions of modern browsers all support MutationObserver – Chrome, Mozilla, IE 11 (not 10 or earlier though!), Safari and mobile Safari all work with it, which is great.

The MutationObserver API lets you monitor elements for changes on the element, in it’s body and in child elements and from my testing this interface here on both desktop and mobile devices it looks like it’s pretty efficient with events being picked instantaneously even on moderately complex pages/elements.

Here’s what the base syntax looks like to use MutationObserver:

var element = document.getElementById("Notebox");

var observer = new MutationObserver(observerChanges);
observer.observe(element, {
    attributes: true,
    subtree: opt.watchChildren,
    childList: opt.watchChildren,
    characterData: true

/// when you're done observing

function observerChanges(mutationRecord, mutationObserver) {

You create a MutationObserver instance and pass a callback handler function that is called when a mutation event occurs. You then call the .observe() method to actually start monitoring events. Note that you should store away the MutationObserver instance somewhere where you can access it later to call the .disconnect() method to unload the observer. This turns out is pretty important as you need to also watch for recursive events and need to unhook and rehook the observer potentially in the callback function. More on the later when I get back to the plug-in.

Note that you can specify what you want to look at. You can look at the current element’s attributes, the character content as well as the DOM subtree so you can actually detect child element changes as well. If you’re only interested in the actual element itself be sure to set childlist and subtree to false to avoid the extra overhead of receiving events for children.

The callback function receives a mutationRecord and an instance of the mutation observer itself. The mutationRecord is the interesting part as it contains information about what was modified in the element or subtree. You can receive multiple records in a single call which occurs if multiple changes are made to the same attribute or DOM operation.

Here’s what the Mutation record looks like:


You can see that you that you get information about whether the actual element was changed via the attributeName or you check for added and removed nodes in child elements. In the example above I used code to make a change to the Class element – twice. I did a jQuery .removeClass(), followed by an addClass(), which triggered these two mutation records.

Note that you don’t have to look at the actual mutation record itself and you can use the MutationObserver merely as a mechanism that something has changed. In the jquery-watch plug-in I’m about to describe, the plug-in keeps track of the properties we’re interested in and it simply reads the properties from the DOM when a change is detected and acts upon that. While  a little less efficient it makes for much simpler code and more control over what you’re looking for.

Adapting the jquery-watch plug-in

So the updated version of the jquery-watch plug-in now uses the MutationObserver API with a fallback to setInterval() polling for events. The plug-in syntax has also changed a little to pass an options object instead of a bunch of parameters that were passed before in order to allow for additional options. So if you’re updating from an older version make sure you check your calls to this plug-in and adjust for the new parameter signature.

First add a reference to jQuery and the plug-in into your page:

<script src="//"></script>
<script src="scripts/jquery-watch.js"></script>

Then simply call the .watch() method on a jQuery selector:

// hook up the watcher
    // specify CSS styles or attribute names to monitor
    properties: "top,left,opacity,attr_class",

    // callback function when a change is detected
    callback: function(data, i) {
        var propChanged = data.props[i];
        var newValue = data.vals[i];

        var el = this;
        var el$ = $(this);

        // do what you need based on changes
        // or do your own checks

The two required option parameters are shown here: A comma delimited list of CSS styles or Attribute names. Attribute names need to be prefixed with a attr_ as in attr_class or attr_src etc. You also need to give a callback function that receives notifications when a change event is raised. The callback is called whenever one of the specified properties changes. The callback function receives a data object and an index. The data object contains .props and .vals arrays, which hold properties monitored and the value that was just captured. The index is the index into these arrays for the property that triggered the change event in the first place. The this pointer, is scoped to the element that initiated the change event – the element jQuery-watch is watching.

Note that you don’t have to do anything with the parameters – in fact I typically don’t. I usually only care to be notified and then check other values to see what I need to adjust, or just set a number of values in batch.

A quick Example – Shadowing and Element

Let’s look at a silly example that nevertheless demonstrates the functionality nicely. Assume that I have two boxes on the screen and I want to link them together so that when I move one the other moves as well. I also want to detect changes to a couple of other states. I want to know when the opacity changes for example for a fade out/in so that both boxes can simultaneously fade. I also want to track the display style so if the box is closed via code the shadow goes away as well. Finally to demonstrate attribute monitoring, I also want to track changes to the CSS classes assigned to the element so I might want to monitor the class attribute.

Let’s look at the example in detail. There are a couple of div boxes on a page:

<div class="container">
    <div id="notebox" class="notebox">
            This is the master window. Go ahead drag me around and close me!
            The shadow window should follow me around and close/fade when I do.
            There's also a timer, that fires and alternates a CSS class every
            3 seconds.

    <div id="shadow" class="shadow">
        <p>I'm the Shadow Window!</p>
        <p>I'm shadowing the Master Window.</p>
        <p>I'm a copy cat</p>
        <p>I do as I'm told.</p>


#notebox is the master and #shadow is the slave that mimics the behavior in the master.

Here’s the page code to hook up the monitoring:

var el = $("#notebox");


// Update a CSS Class on a 3 sec timer var state = false; setInterval(function () { $("#notebox") .removeClass("class_true") .removeClass("class_false") .addClass("class_" + state); state = !state; }, 3000); // *** Now hook up CSS and Class watch operation{ properties: "top,left,opacity,display,attr_class", callback: watchShadow }); // this is the handler function that responds // to the events. Passes in: // data.props[], data.vals[] and an index for active item function watchShadow(data, i) { // you can capture which attribute has changed var propChanged = data.props[i]; var valChanged = data.vals[i]; showStatus(" Changed Property: " + propChanged + " - New Value: " + valChanged); // element affected is 'this' #notebox in this case var el = $(this); var sh = $("#shadow");

// get master current position var pos = el.position(); var w = el.outerWidth(); var h = el.outerHeight(); // and update shadow accordingly sh.css({ width: w, height: h, left: pos.left + w + 4, top:, display: el.css("display"), opacity: el.css("opacity") }); // Class attribute is more tricky since there are // multiple classes on the parent - we have to explicitly // check for class existance and assign sh.removeClass("class_true") .removeClass("class_false"); if (el.hasClass("class_true")) sh.addClass("class_true"); }

The code starts out making the #notebox draggable and closable using some helper routines in ww.jquery.js. This lets us test changing position and closing the #notebox so we can trigger change events. The code also sets up a recurring 3 second switch of a CSS class in the setInterval() code.

Then the actual $().watch() call is made to start observing various properties:{
    properties: "top,left,opacity,display,attr_class",
    callback: watchShadow

This sets up monitoring for 4 CSS styles, and one attribute. Top and left are for location tracking, opacity handles the fading and display the visibility. attr_class (notice the attr_ prefix for an attribute) is used to be notified when the CSS class is changed every 3 seconds. We also provide a function delegate that is called when any of these properties change specifically the watchShadow function in the example.

watchShadow accepts two parameters – data and an index. data contains props[] and vals[] arrays and the index points at the items that caused this change notification to trigger. Notice that I assign the propChanges and newValue variables, but they are actually not used which is actually quite common. Rather I treat the code here as a mere notification and then update the #shadow object based on the current state of #notebox.

When you run the sample, you’ll find that the #shadow box moves with #notebox as it is dragged, fades and hides when #notebox fades, and adjusts its CSS class when the class changes in #notebox every 3 seconds. If you follow the code in watchShadow you can see how I simply recalculate the location and update the CSS class according to the state of the parent.

Note, you aren’t limited to simple operations like shadowing. You can pretty much do anything you like in this code block, such as detect a change and update a total somewhere completely different in a page.

The actual jquery-watch Plugin

Here’s the full source for the plug-in so you can skim and get an idea how it works (you can also look at the latest version on Github):

/// <reference path="jquery.js" />
Version 1.11 - 10/27/2014
(c) 2014 Rick Strahl, West Wind Technologies

Licensed under MIT License
(function ($, undefined) {
    $ = function (options) {
        /// <summary>
        /// Allows you to monitor changes in a specific
        /// CSS property of an element by polling the value.
        /// when the value changes a function is called.
        /// The function called is called in the context
        /// of the selected element (ie. this)
        /// Uses the MutationObserver API of the DOM and
        /// falls back to setInterval to poll for changes
        /// for non-compliant browsers (pre IE 11)
        /// </summary>            
        /// <param name="options" type="Object">
        /// Option to set - see comments in code below.
        /// </param>        
        /// <returns type="jQuery" /> 

        var opt = $.extend({
            // CSS styles or Attributes to monitor as comma delimited list
            // For attributes use a attr_ prefix
            // Example: "top,left,opacity,attr_class"
            properties: null,

            // interval for 'manual polling' (IE 10 and older)            
            interval: 100,

            // a unique id for this watcher instance
            id: "_watcher",

            // flag to determine whether child elements are watched            
            watchChildren: false,

            // Callback function if not passed in callback parameter   
            callback: null
        }, options);

        return this.each(function () {
            var el = this;
            var el$ = $(this);
            var fnc = function (mRec, mObs) {
      ,, mRec, mObs);

            var data = {
                vals: [',').length],
                func: opt.callback, // user function
                fnc: fnc, // __watcher internal
                interval: opt.interval,
                intervalId: null
            // store initial props and values
            $.each(data.props, function(i) {
                if (data.props[i].startsWith('attr_'))
                    data.vals[i] = el$.attr(data.props[i].replace('attr_',''));
                    data.vals[i] = el$.css(data.props[i]);

            el$.data(, data);

            hookChange(el$,, data);

        function hookChange(element$, id, data) {
            element$.each(function () {
                var el$ = $(this);

                if (window.MutationObserver) {
                    var observer = el$.data('__watcherObserver');
                    if (observer == null) {
                        observer = new MutationObserver(data.fnc);
                        el$.data('__watcherObserver', observer);
                    observer.observe(this, {
                        attributes: true,
                        subtree: opt.watchChildren,
                        childList: opt.watchChildren,
                        characterData: true
                } else
                    data.intervalId = setInterval(data.fnc, interval);

        function __watcher(id,mRec,mObs) {
            var el$ = $(this);
            var w = el$.data(id);
            if (!w) return;
            var el = this;

            if (!w.func)

            var changed = false;
            var i = 0;
            for (i; i < w.props.length; i++) {
                var key = w.props[i];

                var newVal = "";
                if (key.startsWith('attr_'))
                    newVal = el$.attr(key.replace('attr_', ''));
                    newVal = el$.css(key);

                if (newVal == undefined)

                if (w.vals[i] != newVal) {
                    w.vals[i] = newVal;
                    changed = true;
            if (changed) {
                // unbind to avoid recursive events

                // call the user handler
      , w, i, mRec, mObs);

                // rebind the events
                hookChange(el$, id, w);
    $.fn.unwatch = function (id) {
        this.each(function () {
            var el = $(this);
            var data =;
            try {
                if (window.MutationObserver) {
                    var observer ="__watcherObserver");
                    if (observer) {
                } else
            // ignore if element was already unbound
            catch (e) {
        return this;
    String.prototype.startsWith = function (sub) {
        if (sub === null || sub === undefined) return false;        
        return sub == this.substr(0, sub.length);
})(jQuery, undefined);

There are a few interesting things to discuss about this code. First off, as mentioned at the outset the key feature here is the use of the MutationObserver API which makes the fast and efficient monitoring of DOM elements possible. The hookChange() function is responsible for hooking up the observer and storing a copy of it on the actual DOM element so we can reference it later to remove the observer in the .unwatch() function.

For older browsers there’s the fallback to the nasty setInterval() code which simply fires a check at a specified interval. As you might expect this is not very efficient as the properties constantly have to be checked whether there are changes or not. Without a notification an interval is all we can do here. Luckily it looks like this is now limited to IE 10 and earlier for now which is not quite optimal but at least functional on those browser. IE 8 would still work with onPropertyChange but I decided not to care about IE 8 any longer. IE9 and 10 don’t have onPropertyChange event any longer so setInterval() is the only way to go there unfortunately.

Another thing I want to point out is that the __watcher() function which is the internal callback that gets called when a change occurs. It fires on all mutation event notifications and then figures out whether something we are monitoring has changed. If it is it forwards the call to your handler function.

Notice that there’s code like this:

if (changed) {
  // unbind to avoid event recursion

  // call the user handler, w, i);

   // rebind the events
   hookChange(el$, id, w);

This might seem a bit strange – why am I unhooking the handler before making the callback call? This code removes the MutationObserver or setInterval() for the duration of the callback to your event handler.

The reason for this is that if you make changes inside of the callback that effect the monitored element new events are fired which in turn fire events again on the next iteration and so on. That’s a quick way to an endless loop that will completely lock up your browser instance (try it – remove the unwatch/hookchange calls and click the hide/show buttons that fade out – BOOM!).  By unwatching and rehooking the observer this problem can be mostly avoided.

Because of this unwatch behavior, if you do need to trigger other update events through your watcher, you can use setTimeout() to delay those change operations until after the callback has completed. Think long and hard about this though as it’s very easy to get this wrong and end up with browser deadlock. This makes sense only if you act on specific property changes and setting other properties rather than using a global update routine as my sample code above does.

Watch on

I’m glad I found the time to fix this plugin and in the process make it work much better than before. Using the MutationObserver provides a much smoother experience than the previous implementations – presumably this API has been optimized better than DOMAttrModified and onpropertychange were, and more importantly you can control what you want to listen for with the ability to only listen for changes on the actual element.

This is not the kind of component you need very frequently, but if you do – it’s very useful to have. I hope some of you will find this as useful as I have in the past…


© Rick Strahl, West Wind Technologies, 2005-2014
Posted in JavaScript  jQuery  HTML5  

by Rick Strahl at October 20, 2014 10:42 AM

Alex Feldstein

October 19, 2014

Alex Feldstein

October 18, 2014

Alex Feldstein

October 17, 2014

Alex Feldstein

The Unbelievers

This is wonderful movie were the camera follows Richard Dawkins and Lawrence Krauss through a series of conferences at universities all over the world.

In this video, Lawrence Krauss and the producers of "The Unbelievers" talk about the film, the story of science, and the necessary discussions about skepticism in regard to religious claims.

The movie is at Netflix.


by Alex Feldstein ( at October 17, 2014 01:01 AM

Morgan Housel: Some Things to Remember About Market Plunges

Morgan Housel posted a great article, as it is usual for him.

“The funniest thing about markets is that all past crashes are viewed as an opportunity, but all current and future crashes are viewed as a risk.”

This should be something you should always remember.

See the whole article at The Motley Fool:

by Alex Feldstein ( at October 17, 2014 12:52 AM

October 16, 2014

Alex Feldstein

Rick Strahl's FoxPro and Web Connection Web Log

SSL Vulnerabilities and West Wind Products

Several people have sent me frantic email messages today in light of the latest POODLE SSL vulnerability and whether it affects West Wind products.

The vulnerability essentially deals with older SSL protocol bugs and the concern is especially on the server that protocol fallback from TLS to SSL can cause problems. Current protocols are TLS vs. the older SSL technology. Only the older SSL stacks are vulnerable. This is most critical on Web Servers, and you'll want to disable the older SSL protocols on IIS and leave only TLS enabled. TLS is the newer standard that superseded  SSL, although we still talk about SSL certificates – most modern certificates are actually TLS certificates and have support for SSL for fallback validation.

You can check your server’s SSL certificate status here:

You’ll want to see that all versions of SSL are either disabled or at the very least that the server doesn’t support protocol fallback to SSL protocols.

When I ran this for my site running Server 2008 (IIS 7.0) I found SSL3 enabled, but the server not supporting automatic protocol fallback which avoids the main POODLE issue. I’ve since disabled SSL V3 on the server. The good news is, that while the certificate isn’t using maximum strength, the server was not found to be vulnerable from this issue even with the default settings in place.

Disabling SSL on IIS

If you see that SSL versions are enabled even if you have TLS certificates (which just about all of them should be by now) you can disable specific protocols. This is done through registry keys, but be aware that this is global for the entire machine. You can disable/enable protocols for both the client and server.

Here's a KB article from Microsoft to check out that tells you how to disable older SSL protocols.

SSL and WinInet

The West Wind Client Tools and specifically the wwHTTP class rely on the Windows WinInet library to provide HTTP services. The POODLE issue is much less critical for the client as the client is the actually attacking entity. But I double checked here on my local machine and I can see that WinInet uses TLS 1.2 on my Windows 8.1 when connecting to a certificate on the server.

Capturing an https:// session from Fiddler shows the following request header signature on the CONNECT call:

Version: 3.3 (TLS/1.2)
Random: 54 3F 15 D6 B5 3E 6B F5 AD 71 41 FB 4C 39 B9 30 C5 21 04 A4 76 7F 87 A5 1A BA D6 83 19 B3 10 3B
SessionID: empty

which suggests TLS/1.2 as the initial request sent.

I don’t know what older versions of Windows – XP in particular use – but I suspect even XP will be using TLS/1.0 at the very least at this point. Maybe somebody can check (Use Fiddler, disable Decrypt HTTPS connections option, then capture HTTPS requests and look at the raw request/response headers.

Nothing to see here

From the West Wind perspective this issue is not specific to the tools, but to the operating system. So make sure the latest patches are installed and that if you have to remove the server SSL certificates. Client software is not really at risk, since the attack vector is a receiving Web Server. Regardless even the client tools appear to be using the latest safer protocols and so any West Wind tools are good to go.

by Rick Strahl at October 16, 2014 01:32 AM

October 15, 2014

Alex Feldstein

Article: How to ruin your life (most of us do)

One of my all-time favorite writers, Morgan Housel, gives excellent advice on how to ruin your financial life. Morgan is a staff writer for The Motley Fool. Until I became an avid Fool years ago, I was guilty of many of these behaviors, as most of us are. Pay attention!
Article: How ro ruin your life

by Alex Feldstein ( at October 15, 2014 12:10 PM

October 14, 2014

Beth Massi - Sharing the goodness

Getting Started with the Office 365 APIs

This weekend I had the pleasure of speaking on a couple of Office Development topics at Silicon Valley Code Camp, as well as the East Bay.NET user group meeting on Thursday (with special Halloween guest). It was great to pack three talks into one week as I’ve been doing so much internal-facing work lately, that I have been really itching to get back out to speak in front of the developer community.

One of the areas I’ve been working in for a while is building SharePoint Apps. Office and SharePoint Apps let you customize the Office and SharePoint experiences with your own customizations. Apps are web-based, and you use HTML and JavaScript to customize Office (Outlook, Word, Excel, PowerPoint) and SharePoint itself.


For more info on apps, see the MSDN Library: Apps for Office and SharePoint

We’ve also been working on another programming model that I’m really jazzed about. It allows you to build your own custom apps and consume data from Office 365 (Sites, Mail, Calendar, Files, Users). They are simple REST OData APIs for accessing SharePoint, Exchange and Azure Active Directory from a variety of platforms and devices. You can also use these APIs to enhance custom business apps that you may already be using in your organization.


To make it even easier, we’ve built client libraries for .NET, Cordova and Android. The .NET libraries are portable so you can use them in Winforms, WPF, ASP.NET, Windows Store, Windows Phone 8.1, Xamarin Android/iOS,. There’s also JavaScript libraries for Cordova and an Android (Java) SDK available.


If you have Visual Studio this gets even easier by installing the Office 365 API Tools for Visual Studio extension. The tool streamlines the app registration and permissions setup in Azure as well as adds the relevant client libraries to your solution via NuGet for you.

Before you begin, you need to set up your development environment.


Note that the tools and APIs are currently in preview but they are in great shape to get started exploring the possibilities. Read about the client libraries here and the Office 365 APIs in the MSDN Library. More documentation is on the way!

Let’s see how it works. Once you install the tool, right-click on your project in the Solution Explorer and select Add – Connected Service...


This will launch the Services Manager where you log into your Office 365 developer site and select the permissions you require for each of the services you want to use.


Once you click OK, the client libraries are added to your project as well as sample code files to get you started. The client libraries help you perform the auth handshake and provide strong types for you to work with the services easier.

The important bits..

const string MyFilesCapability = "MyFiles";
static DiscoveryContext _discoveryContext;

public static async Task<IEnumerable<IFileSystemItem>> GetMyFiles()
    var client = await EnsureClientCreated();

    // Obtain files in folder "Shared with Everyone"
    var filesResults = await client.Files["Shared with Everyone"].
    var files = filesResults.CurrentPage.OrderBy(e => e.Name);

    return files;
public static async Task<SharePointClient> EnsureClientCreated()
    if (_discoveryContext == null)
        _discoveryContext = await DiscoveryContext.CreateAsync();

    var dcr = await _discoveryContext.DiscoverCapabilityAsync(MyFilesCapability);
    var ServiceResourceId = dcr.ServiceResourceId;
    var ServiceEndpointUri = dcr.ServiceEndpointUri;

    // Create the MyFiles client proxy:
    return new SharePointClient(ServiceEndpointUri, async () =>
        return (await _discoveryContext.AuthenticationContext.
            new Microsoft.IdentityModel.Clients.ActiveDirectory

This code is using the Discovery Service to retrieve the rest endpoints (DiscoverCapabilityAsync). When we create the client proxy, the user is presented with a login to Office 365 and then they are asked to grant permission to our app. Once they authorize, we can access their Office 365 data.

If we look at the request, this call:

    var filesResults = await client.Files["Shared with Everyone"].

translates to (in my case):

GET /personal/beth_bethmassi_onmicrosoft_com/_api/Files('Shared%20with%20Everyone')/Children

The response will be a feed of all the file (and any sub-folder) information stored in the requested folder.

Play around and discover the capabilities. There’s a lot you can do. I encourage you to take a look at the samples available on GitHub:

Also check out these video interviews I did this summer to learn more:


by Beth Massi - Microsoft at October 14, 2014 04:28 PM

Alex Feldstein

October 13, 2014

FoxCentral News

No change - Last chance - Chicago FUDG - TUESday the 14th

 It is the last day to register for A SPECIAL EVENT: Christof Wollenhaupt will be presenting live and in person to the Chicago FUDG on Tuesday the 14th of Oct. previewing his SWFox presentation: "Lessons Learned from SQL Server". Please RSVP at the Eventbrite link on our web page. This is a must-see presention!!

by Chicago FoxPro Users and Developers Group at October 13, 2014 11:31 AM

Last change - Chicago FUDG - TUESday the 14th

 It is the last day to register for A SPECIAL EVENT: Christof Wollenhaupt will be presenting live and in person to the Chicago FUDG on Tuesday the 14th of Oct. previewing his SWFox presentation: "Lessons Learned from SQL Server". Please RSVP at the Eventbrite link on our web page. This is a must-see presention!!

by Chicago FoxPro Users and Developers Group at October 13, 2014 11:27 AM

Alex Feldstein

October 12, 2014

The Problem Solver

Using browserify to manage JavaScript dependencies

Managing JavaScript dependencies in the browser is hard. Library scripts typically create global variables and functions. Other scripts now depend on those global objects to do their work. This works but in order to load all required scripts we have to add <script> elements to our HTML, making sure to add them in the right order, and basically know what each exposes.

The problem

Consider the following client side code:

   1: // Print a message
   2: utils.print("Hello");


This depends on another piece of script below:

   1: // Expose the utility object with it's print function
   2: var utils = {
   3:     print: function(msg){
   4:         console.log(msg);
   5:     }
   6: };


And for all of that to work we have to load the scripts in the right order using some HTML as below:

   1: <!DOCTYPE html>
   2: <html>
   3: <head lang="en">
   4:     <meta charset="UTF-8">
   5:     <title>Browserify demo</title>
   6: </head>
   7: <body>
  10: <script src="utils.js"></script>
   2: <script src="demo.js">
  12: </body>
  13: </html>


Not really rocket science here but if we want update utils.print() to call a printIt() function loaded from yet another library we have to go back to our HTML and make sure we load the printIt.js as well. Easy in a small app but this can become hard and error prone with larger applications.


Browserify to the rescue

Using browserify will make managing these dependencies a lot easier. To understand how it works we first must take a quick look at how NodeJS modules work.

With node each module can take a dependency on another module by requiring it using the require() function. And each module can define what it exports to other modules by using module.exports. The NodeJS runtime takes care of loading the files and adding dependencies inside a module will not require a change anywhere else in the program.

This system works really nice but unfortunately the browser doesn’t provide this NodeJS runtime capability. One problem here is that a call to require() is a synchronous call that returns the loaded module while the browser does all of its IO asynchronously. In the browser you can use something like RequireJS to asynchronously load scripts but while this works file this is not very efficient due to its asynchronous nature. As a result people usually use RequireJS during development and then create a bundle with all the code for production.

Browserify on the other hand will allow us to use the synchronous NodeJS approach with script loading in the browser. This is done by packaging up all files required based on the require() calls and creating one file to load at runtime. Converting the example above to use this style requires some small changes in the code.

The demo.js specifies it requires utils.js. The syntax “./utils” means that we should load the file from the same folder.

   1: var utils = require("./utils");
   2: // Print a message
   3: utils.print("Hello");


Next the utils.js specifies what it exports:

   1: // Expose the utility object with it's print function
   3: var utils = {
   4:     print: function(msg){
   5:         console.log(msg);
   6:     }
   7: };
   9: module.exports = utils;


Next we need to run browserify to bundle the file for use in the browser. As browserify is a node application we need to install node and then, through the node package manager NPM, install browserify with

   1: npm install -g browserify


With browserify installed we can bundle the files into one using:

   1: browserify demo.js > bundle.js

This will create a bundle.js with the following content:

   1: (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2: var utils = require("./utils");
   3: // Print a message
   4: utils.print("Hello");
   6: },{"./utils":2}],2:[function(require,module,exports){
   7: // Expose the utility object with it's print function
   9: var utils = {
  10:     print: function(msg){
  11:         console.log(msg);
  12:     }
  13: };
  15: module.exports = utils;
  16: },{}]},{},[1]);


Not the most readable but then that was not what it was designed to do. Instead we can see all code we need is included. Now by just including this generated file we ready to start our browser application.

Adding the printIt() function

Doing the same change as above is simple and best of all doesn’t require any change to the HTML to load different files. Just update utils.js to require() printIt.js and explicity export the function in printIt.js, rerun browserify and you are all set.

   1: function printIt(msg){
   3: }
   5: module.exports = printIt;


Note that it’s fine to just export a single function here.


   1: // Expose the utility object with it's print function
   2: var printIt = require("./printIt");
   4: var utils = {
   5:     print: function(msg){
   6:         printIt(msg);
   7:     }
   8: };
  10: module.exports = utils;

And the result of running browserify is:

   1: (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
   2: var utils = require("./utils");
   3: // Print a message
   4: utils.print("Hello");
   6: },{"./utils":3}],2:[function(require,module,exports){
   7: function printIt(msg){
   9: }
  11: module.exports = printIt;
  13: },{}],3:[function(require,module,exports){
  14: // Expose the utility object with it's print function
  15: var printIt = require("./printIt");
  17: var utils = {
  18:     print: function(msg){
  19:         printIt(msg);
  20:     }
  21: };
  23: module.exports = utils;
  24: },{"./printIt":2}]},{},[1]);

Again not the most readable code but the printIt() function is now included. Nice and no changes required to the HTML :-)

Proper scoping

As a side benefit browserify also wraps all our JavaScript files in a function ensuring that proper scope for variables is used and we don’t accidently leak variables to the proper scope.


Using browserify works really nice but this way we do have to start it after every time. In the next blog post I will show how to use Gulp or Grunt to automate this making the workflow a lot smoother.



by Maurice de Beijer at October 12, 2014 07:30 PM

Alex Feldstein

October 11, 2014



Links to blogs that have something to do with VFP, or by VFP folks

Active Blogs See also Twitter Gallery /
Author Home Page Feed
Alex Feldstein
Andrew Coates
Andrew MacNeill - AKSEL Solutions
Andrew MacNeill - Learning Visual FoxPro
Andrew MacNeill - Fox Show Pod Cast
Andy Kramek
Arnon Rotem-Gal-Oz NONE - removed by Dr Dobbs
Beth Massi
Bernard Bout - Making VFP look cool.
Bo Durban
Boudewijn Lutgerink
Calvin Hsia
Cathy Pountney
Cetin Basoz
Christof Wollenhaupt
John Koziol - Gonzo Maximus Blog - Musings on VFP, SDLC, and whatnot
Chris Sainty
Craig Bailey Main blog
Craig Berntson
Craig S Boyd
Dave Bernard
Dave Crozier
David T Anderson
David Stevenson Blog Down for two weeks was
Del Lee
Doug Hennig
Esparta Palma
Fernando D Bozzo
Franklin Garz�n
Frank Perez
Nancy Folsom
Foxite Community Blog -- All
Guineu Release Blog
Richard Camelo K. Base - foxpro.catalyst
Joel Leach
Ken Levy
Kevin Cully
Kevin McNeish MIA, was: MIA
Kevin Ragsdale
Jochen Kirstäter (aka JoKi)
Juan Calcagno GONE: Offline
Kok Kiet John Jones
Lisa Slater Nicholls
Martin Salias
Martin Pirringer MYSQL Blog (VFP -> MYSQL migration)
Matt Slay
Maurice De Beijer
Nadya Nosonovsky
Patrick Bibro BROKEN: missing
Paul Mrozowski
PEM Editor (Jim Nelson)
Philadelphia VFP User Group
Pro Sys Plus ( Hank Fay ) Offline
Rahul Desai
Rick Borup
Rick Schummer Shedding Some Light v2.0

Rick Strahl General/.NET
Rick Strahl FoxPro / Web Connection
Rod Paddock OLDER:


Ronald Ramirez Moran
Sergey Berezniker
Simon Arnold
Southwest Fox
Stephen Bodnar
Steve Davis
Steve Ellenoff
Stuart Dunkeld
Ted Roche
Tod McKenna TodMeansFox
Visionpace Blog
VFP Imaging - GDI+ articles and tips
VS DATA Team's Blog
F 1 Technologies
Randy Jean
Tom Borgmann Tom's VFP Blog (in German)
Tom Meeks' Beginning Visual FoxPro Tips
William Sanders TerraFox Publishing
Victor Espina (in Spanish / en Espanol) (not available at this time)
Y Alan Griver
Alan Stevens
Walt Krzystek
VFP Developers
Vassilis Aggelakos
Mark Gordon
Portal Fox (In Spanish)
Comunidad VFP en Español
Planet FoxPro
foxpro rss feed agregator
wOOdy's Blog (in German)
Jun Tangunan's Sand Storm 35 blog

October 11, 2014 12:02 PM

Alex Feldstein

October 10, 2014



Rick Schummer is the president and lead geek at his company White Light Computing, which is headquartered in southeast Michigan, USA. He prides himself in guiding his customers' Information Technology investment toward success. He enjoys working with top-notch developers; has a passion for developing software using best practices, and for surpassing customer expectations, not just meeting them. After hours he writes developer tools that improve productivity and occasionally pens articles for Fox RockX, Fox Talk, Advisor Guide to Microsoft Visual FoxPro (formerly FoxPro Advisor), CoDe Magazine, and several user group newsletters.

Rick owns another company called Geek Gatherings, LLC focusing on training developers through the use of conferences and formal training sessions. The initial offering of Geek Gatherings, LLC is the Southwest Fox Conference. In 2012 we added the Southwest Xbase++ Conference for developers who use Alaska Software's Xbase++. These conference are currently held in Gilbert Arizona at the SanTan Elegante Conference & Reception Center/Legado Hotel. Advanced training sessions remain in the planning stages. You can register through

Previous to these endeavors Rick was a Partner at Geeks and Gurus, Inc. for three years, and served as Director of Development and as a Senior Application Developer for Kirtland Associates, Inc. for two and a half years. He not only wrote code, researched and evaluated technology, and managed customer projects for this organization, but also participated in the education of new and experienced Visual FoxPro developers. Prior to Kirtland, Rick worked for Electronic Data Systems (EDS) for nine years as an Advanced Systems Engineer. There Rick wrote a number of applications for General Motors (Fortune 7, although Fortune 1 when he was there {g}) and GMAC Financial Services. His applications still run in over 300 locations across North and South America. Each of these experiences taught Rick what to do and not to do in his own company.

Awarded the FoxPro Lifetime Achievement Award at Southwest Fox 2010 Conference. This award starts with nominations from the Fox Community, and is determined by a committee of past recipients, Y. Alan Griver from Microsoft, and a representative from the Fox Community. Rick was literally speechless when his name was announced by Doug Hennig, and is very honored to be recognized by his peers in a community he loves being part of.

He is the architect and lead developer of the WLC Hack CX Professional tool available from White Light Computing and is not-so-hard at work on a Menu Designer replacement, expected to ship before the end of the century. You can find a smattering of free tools on his Web site as well.

In February 2002 Microsoft awarded Rick their Microsoft Most Valuable Professional (MVP). He was recognized again for the year 2002-2003, 2003-2004, 2004-2005, 2005-2006, 2006-2007, 2007-2008, 2008-2009, 2009-2010, and 2010-2011.

Looking for details on installing VFP 9 SP2 side-by-side with other versions of VFP 9? Check out this white paper with all the details:

Writing Credentials:
He has used all DOS and Windows versions of Fox since FoxBase+ and started writing with dBASE III and Buttonware's PC-File way back in the mid 1980's.

Rick is a founding member and secretary of the Detroit Area Fox User Group (DAFUG) and past president and secretary of the Sterling Heights Computer Club. He is a regular presenter at the meetings of these organizations, presents at Fox user groups and conferences across North America, has presented for Microsoft at Dev Days, at the Great Lakes Great Database Workshop 2000-2003 and 2006, Essential Fox 2002-2004, Southwest Fox 2004-2014, VFE DevCon 2002 and 2005, German DevCon 2005-2014, Advisor DevCon 2006-2007, OzFox 2007, and DevLink 2010-2011.

Blog: Shedding Some Light found at
Twitter: @rschummer,,,

October 10, 2014 10:32 PM

Alex Feldstein

October 09, 2014



Editor comments: Updated for 2014 (formerly dormant since 2011?!)

October 09, 2014 08:48 PM

Alex Feldstein

Rick Strahl's Web Log

Chrome DevTools Debugging Issues

So it looks like Chrome 39 Canary has this issue fixed. Let’s hope when v39 release lands it’s still be working…

Since the last few Chrome releases have come out (v38 as of this writing), I’ve had some major issues with debugging not working properly. The behavior I see is pretty strange but it’s repeatable across different installations, so I thought I’d describe it here and then link it to a bug report.

What’s happening is that I have had many instances where the debugger is stopping on a breakpoint or debugger; statement, but is not actually showing the source code. I can see the debugger is stopping because the black screen pops up and I can see the play button in the debugger window.

What’s odd is that it works and the debugger stops the first time after I start the browser. If I reload the page a second or third time though, the debugger still stops, but doesn’t show the source line or even the right source file.

This is not an isolated instance either. I initially started seeing this issue with an Angular application, where the debugger would exhibit this same behavior in some situations, but not in others. Specifically it appeared the debugger worked in straight ‘page load’ type code – it stops and shows source code properly. But when setting a breakpoint inside of event code – an ng-click operation for example – the debugger again would stop, but not show the source code.


So here’s a simple example from I kept the script inline for keeping it simple, but whether the script is embedded or external really makes no difference to the behavior I see.

The page has a small bit of copied script in it that scrolls the page when you click one of the in page anchor links that navigate to hash tags that exist in the page. The code works now, but I initially had to make a few changes to make it work on my page from the original source.  Inside of jquery click handler I have the following code:

$("a[href*=#]:not([href=#])").on("click", function (e) {

Now when I do this on my local machine I get the following in Chrome 38:


In this example, because it’s all one page the page at least is loaded, but when I had problems with my Angular app, the right source file wasn’t even opened.

Now if I hit the same exact page (just uploaded) on my live site I get the proper debugger functionality – but only on the first load. Reloading the page again after a restart I see the same behavior I see on localhost.

First load looks like this (correct behavior):


But then subsequent requests fail again…

What I’ve Tried

My initial thought has been that there’s something wrong with my local Chrome installation, so I completely uninstalled Chrome, and Canary, rebooted and the reinstalled Chrome from scratch. But I got no relief from that exercise. I was hopeful that Chrome 38 which landed today (and replaced the generally messy 37 release) might help but unfortunately the problem persists.

I also disabled all plug-ins but given that my version on a remote machine worked with all plug-ins running makes me think it’s not the plug-ins.

Still thinking it might be something machine specific I fired up one of my dev VMs and tried checking out the code in there – and guess what same behavior. So it doesn’t look like this is a configuration issue in Chrome but some deeper bug with the source parsing engine.

I had also thought that with the Angular app earlier the problem might have been some issue with script parsing or map files, but even using non-minified scripts I ended up with the same issue.

I also experimented with the breakpoint options in the browser’s source tab which lets you disable breakpoints from stopping. This had no effect, since it doesn’t appear this option affects debugger statements, only actual breakpoints set in the debugger itself.

Finally I tried the nuclear option: I ran the Chrome Software Removal Tool to completely nuke and reset my settings. It removes plug-ins, clears history and cookies, resets config: settings and otherwise completely resets Chrome. Other than plug-ins I don’t really have much in the way of customizations, so I didn’t think this would really help and sure enough it didn’t – the errant behavior continues.

Update: Looks like Chrome 40 has fixed this behavior

I noticed that when installing a Canary update yesterday, started to show the problem going away. In Canary Version 40+ breakpoints are doing the right thing and showing source code!

Nasty Bug

This is an insidious bug – and it’s been plaguing me for a few weeks now. In this page this isn’t exactly a big deal but in a recent larger AngularJs app I was working on I constantly ran into this problem and it was bad enough I ended up switching to FireFox for all debugging purposes. FireFox and Firebug work fine (as do the IE DevTools) but I generally prefer running in Chrome because overall the tools are just a little easier to work with in my daily workflow, so I’d like to get to the bottom of this issue.

So my question is – has anybody else run into this weird problem where some pages are not debugging? Any ideas on what to else to try? I did submit an issue to Google – lets see if anything comes of that.

© Rick Strahl, West Wind Technologies, 2005-2014

by Rick Strahl at October 09, 2014 06:02 AM

Alex Feldstein

October 08, 2014



Editor comments: Blogs gone missing

October 08, 2014 03:43 PM


Editor comments: Bumped Chicago's October meeting

October 08, 2014 01:44 PM

Alex Feldstein

October 07, 2014

FoxCentral News

Philadelphia VFP User Group--October 14--Toni Feltman Double-header

The next meeting of the Philadelphia VFP User Group will be next Tuesday, October 14, 2014 at 7 PM in Room 104, DeVry University, 1140 Virginia Drive, Fort Washington, PA. (Note the change of room.) As usual, feel free to bring something to eat and arrive as early as 6:30. We continue our Southwest Fox previews this month. Toni Feltman will (remotely) present both of her Southwest Fox 2014 sessions: "I Need a REST!" and "Should I be Concerned?"

by Philadelphia Visual FoxPro User Group at October 07, 2014 08:20 PM

VFP Philly

October 14: Toni Feltman double-header

Note the change of room beginning this month. From now on, we'll meet in room 104.

We continue our Southwest Fox previews this month. Toni Feltman will (remotely) present both of her Southwest Fox 2014 sessions.

Title: I Need a REST!
Abstract: Web APIs are one way to enable distributed systems to interact with each other over HTTP. In the past, SOAP-based Web Services were the Web API of choice. Today developers prefer to use RESTful Web APIs to enable system to communicate. Our Visual FoxPro applications are just one of the types of systems that may need to communicate with others over the web. It is very possible, and pretty easy, to do so using RESTful APIs. In order to take advantage of all that is available using the web you must first
understand Web APIs, know how to find them (or write them) and then plug them into your applications.

Title: Should I be Concerned?
Abstract: I remember way back around 1994 when people started talking about the concept of business objects and application layers. I know that when I spoke on the topic, many people looked at me like I was completely nuts. Why would anyone want to add such layers of complexity to an application? Fast forward a couple of years (or decades) and we have complex business applications that are screaming for features that FoxPro can't provide such as Metro interfaces, offline databases, interactions with specialized hardware such as cameras and GPS. I am really glad that I added that layer of complexity back then because moving portions of my applications to other platforms is significantly easier than it could have been. But what about you? How can you retrofit monolithic FoxPro applications into an n-tier model in an efficient manner that does not require extensive rewrite or testing?

Toni Feltman, a Microsoft Certified Professional, is an experienced software developer, project manager, instructor and speaker. Currently Toni serves as the Application Development Manager for CoreLogis, LLC, a Westerville, OH company that specializes in Inventory and Asset management software for local to international government entities. She is also Vice President and a Partner at F1 Technologies and is still an integral part of the company. During her 15 years at F1 Technologies she has served as both a developer and project manager on numerous projects and as Product Manager for the highly successful FoxExpress product line.

Toni is a well known contributor to the Visual FoxPro development community. She has spoken at most major FoxPro conferences in North America and Europe over the last several years. Although Toni has expertise in a number of areas, she generally focuses her presentations on Team Development, XML, n-Tier Development and new features in Visual FoxPro. In 2011, Toni was honored by the FoxPro community with a lifetime achievement award in recognition of her contributions to the community throughout her career.

Toni has penned several articles for Advisor Guide to Microsoft Visual FoxPro and is co-author of What's New in Visual FoxPro 9.0 (Hentzenwerke Publishing). Toni also designed and developed Project HookX, a public domain utility designed to allow developers to manage and use multiple project hooks on a single Visual FoxPro Project. Toni is one of several co-authors of DBCX, a public domain data dictionary tool used or supported by many notable Visual FoxPro products including the Stonefield Data Dictionary, Visual FoxExpress, FoxFire! and Stonefield Query.

Toni taught for several years at the University of Toledo on a wide variety of technologies including Microsoft Office applications, XML, various Internet development technologies and database design and programming. Toni also enjoyed a stint as an instructor for AppDev.

Toni's introduction to the FoxPro community came while she worked in the technical support department at Fox Software. Toni was a senior level support technician and Sysop of the Fox Software Forum on CompuServe.

Toni graduated from Bowling Green State University in 1989 with a BA in Management Information Systems.

by Tamar E. Granor ( at October 07, 2014 08:15 PM



Editor comments: Latest news

October 07, 2014 03:10 PM

FoxCentral News

West Wind Web Connection 5.70 released

 West Wind Technologies has released version 5.70 of its FoxPro Web Application framework today. Web Connection makes it easy to build Web applications using the familar Visual FoxPro environment for development, testing and debugging. Version 5.70 adds new and improved REST service features and JSON improvements to facilitate building rich client JavaScript applications. A new client centric AngularJs mobile-first sample application has been added to demonstrate some of the new REST features and integration between client centric apps and Web Connection. Web Connection is free to try and this is a free upgrade to registered users of version 5.50 and later.

by West Wind Technologies at October 07, 2014 09:47 AM

Alex Feldstein

October 06, 2014

Alex Feldstein

October 05, 2014

Alex Feldstein

October 04, 2014

Alex Feldstein

October 03, 2014



It has been written that a great programmer can be ten times (or more) productive than a mediocre one. In Visual FoxPro, double that ratio since a fox grand wizard knows how to greatly (greatly) minimize the development cycle time.

October 03, 2014 08:24 PM

Doug Hennig

Guidebook for Southwest Fox/Xbase++ 2014

The Guidebook for Southwest Fox/Xbase++ 2014 is now available. If you haven’t used it before, it’s a very cool app that provides speaker bios, session abstracts, and schedules for our conference. You can create your own customized schedule of sessions, even on mobile devices other than iOS and Android, which is new this year. Also new is the ability to sign in as an attendee.

I discussed setup last year, but this year it was even easier because Guidebook now supports uploading speaker images and links. So there was hardly any manual setup at all.

Less than two weeks to go. I hope you’re all as excited as I am!

by Doug Hennig ( at October 03, 2014 07:27 PM

Alex Feldstein

Photo of the Day

Tracy Arm Fjord, Alaska
The ice comes from the Sawyer Glacier nearby, at the end of the fjord.
The little dark shapes on the ice float are harbor seals.

by Alex Feldstein ( at October 03, 2014 11:56 AM