In a nutshell, reactive programming is a not unlike the traditional days of unix shell scripting where you’d pipe streams of text from simple primitives to one another. Here are a couple of examples from the Bash Manual.

ls -l | grep "\.txt$"
ls -l | sed -e "s/[aeio]/u/g" 

You can also combine two streams into one and then do processing on them.

# Look for ERROR string in both stdout and stderr.
foo 2>&1 | grep ERROR

Similarly, if you were doing GUI programming for select objects on a screen, you might wish to implement CTRL+Click as a way to add items to a selection. Doing this using event handlers can lead to a tangle of logic very quickly, especially if CTRL key is also used for other functionality.

Using Reactive programming, you’d essentially express your logic this way: listen to key down event and filter for CTRL key, then launch a listener for the click event, and after that launch listener for KeyUpEvent. This can be all done in one method, so that the logic stays together.

     cat keyDownEvents | grep -l CTRL | xargs 'cat clickEvent' | xargs 'cat keyUpEvents | grep -l CTRL'

More examples would be forthcoming, but in the meantime, I’d like to introduce a way to transform an event handler into an observable stream.

/* the following defines an observable stream of click events on a button btn  */
/* the button's event handler is not hooked up until this observable stream is */
/* subscribed by an Observer. (We pass in a routine to hook up the event       */
/* handler just-in-time.                                                       */
Observable<ActionEvent> clickEvents = OperationToObservableEvent.toObservable(new Action1<EventHandler<ActionEvent>>() {
  @Override
  public void call(EventHandler<ActionEvent> eventHandler) {
    btn.setOnAction(eventHandler);
  }
});

The syntax is rather ugly without type inference, but I’d expect Java 8′s lambdas to improve the readability significantly.

/* We subscribe to the stream here. Make sure you call subscription.close()  */
/* when you are done, or the event handler will cause a memory leak.         */
Subscription subscription = clickEvents.subscribe(new Action1<ActionEvent>() {
        @Override
        public void call(ActionEvent t1) {
          System.out.println("Event Handled" + t1);
        }
      });

And here’s the supporting code:

/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package rx.operators;

import javafx.event.Event;
import javafx.event.EventHandler;
import rx.Observable;
import rx.Observer;
import rx.Subscription;
import rx.util.functions.Action1;
import rx.util.functions.Func1;

/**
 *
 * @author Chui
 */
public class OperationToObservableEvent {

  private static class ToObservableEvent<T extends Event>
          implements Func1<Observer<T>, Subscription>,
          Subscription,
          EventHandler<T> {

    private final Action1<EventHandler<T>> addListener;
    private final Action1<EventHandler<T>> removeListener;
    private Observer<T> observer;

    public ToObservableEvent(
            Action1<EventHandler<T>> addListener,
            Action1<EventHandler<T>> removeListener) {
      this.addListener = addListener;
      this.removeListener = removeListener;
    }

    @Override
    public Subscription call(final Observer<T> observer) {
      this.observer = observer;
      this.addListener.call(this);
      return this;
    }

    @Override
    public void handle(T event) {
      observer.onNext(event);
    }

    @Override
    public void unsubscribe() {
      if (this.removeListener == null)
      {
        // there is no removeEventListener function,
        // so we assume this is a setEventListener,
        // and set it to null
        this.addListener.call(null);
      }
      else
      {
        this.removeListener.call(this);
      }
    }
  }
  
  /**
   * Returns an observable stream of events. 
   * @param <T> the type of events in the stream
   * @param setListener a callback to hook up an event handler when an Observer subscribes to the stream.
   * @return an Observable stream of events of type T
   */
  public static <T extends Event> Observable<T> toObservable(
          Action1<EventHandler<T>> setListener)
  {
    return Observable.create(toObservableEvent(setListener, null));
  }
  
  /**
   * 
   * @param <T> the type of events in the stream
   * @param addListener a callback to hook up event handler when an Observer subscribes to the stream
   * @param removeListener a callback to unhook the event handler when the subscription is done
   * @return an Observable stream of events of type T
   */
  public static <T extends Event> Observable<T> toObservable(
          Action1<EventHandler<T>> addListener,
          Action1<EventHandler<T>> removeListener)
  {
    return Observable.create(toObservableEvent(addListener, removeListener));
  }
  
  /**
   * This is an internal routine.
   * @param <T>
   * @param addListener
   * @param removeListener
   * @return 
   */
  public static <T extends Event> Func1<Observer<T>, Subscription> toObservableEvent(
          Action1<EventHandler<T>> addListener,
          Action1<EventHandler<T>> removeListener)
  {
    return new ToObservableEvent(addListener, removeListener);
  }
}

/*
 * CompositeDisposable is a port of the .NET equivalent
 * Add any subscriptions to a CompositeDisposable, and when 
 * the unsubscribe() is called, all the subscriptions will
 * be unsubscribed at the same time.
 */
package rx.disposables;

import java.util.ArrayList;
import rx.Subscription;

public class CompositeDisposable extends ArrayList<Subscription> 
  implements Subscription, AutoCloseable
{

  @Override
  public void unsubscribe() {
    for(Subscription item: this)
    {
      item.unsubscribe();
    }
  }

  @Override
  public void close() {
    this.unsubscribe();
  }
  
}

However, when you take a look at the XAML, it is not obvious how this is implemented.

<UserControl x:Class="GlobalBehavior.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
    xmlns:local="clr-namespace:GlobalBehavior"
    mc:Ignorable="d"             
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White">
        
        <Button Content="Click Me" Margin="36,28,0,0" HorizontalAlignment="Left" Width="112" Height="47" VerticalAlignment="Top" />
        <Button Content="Click Me" Margin="133,104,0,0" HorizontalAlignment="Left" Width="112" Height="47" VerticalAlignment="Top" />

    </Grid>
</UserControl>

This is done by attaching a behavior to the default Button style. There is a little wrinkle to the trick. The style setters by default is not able to set complex attached dependency properties. However, it can handle simple dependency properties. So, we’d write a simple depedency property that can be attached like this:

        <Style TargetType="Button">
            <Setter Property="local:HideButtonBehavior.ButtonBehaviors" Value="True" />
        </Style>

and the ButtonBehaviors dependency property sets the actual Behaviors on the button.

namespace GlobalBehavior
{
    using System;
    using System.Linq;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Input;
    using System.Windows.Interactivity;
    using System.Windows.Media;
    using System.Windows.Media.Animation;

    public partial class HideButtonBehavior : Behavior<FrameworkElement>
    {        
        #region HideButtonBehavior.ButtonBehaviors depedency property

        public static bool GetButtonBehaviors(DependencyObject obj)
        {
            return (bool)obj.GetValue(ButtonBehaviorsProperty);
        }

        public static void SetButtonBehaviors(DependencyObject obj, bool value)
        {
            obj.SetValue(ButtonBehaviorsProperty, value);
        }

        // Using a DependencyProperty as the backing store for ButtonBehaviors. 
        public static readonly DependencyProperty ButtonBehaviorsProperty =
            DependencyProperty.RegisterAttached("ButtonBehaviors",
            typeof(bool), typeof(Button), new PropertyMetadata(false, ButtonBehaviorsChanged));

        private static void ButtonBehaviorsChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
        {
            var behaviors = Interaction.GetBehaviors(d);
            var existingBehavior = behaviors.FirstOrDefault(b => b.GetType() ==
              typeof(HideButtonBehavior)) as HideButtonBehavior;
            if ((bool)e.NewValue == false &amp;&amp; existingBehavior != null)
            {
                behaviors.Remove(existingBehavior);
            }
            else if ((bool)e.NewValue == true &amp;&amp; existingBehavior == null)
            {
                /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
                /* !!! THE REST ARE ALL BOILERPLATE. THE REAL GOODNESS IS HERE !!! */
                behaviors.Add(new HideButtonBehavior());
                /* !!!                                                         !!! */
                /* !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
            }
        }

        #endregion

    }
}

and for completeness, here’s the code for the silly Button behavior.

namespace GlobalBehavior
{
    using System;
    using System.Linq;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Input;
    using System.Windows.Interactivity;
    using System.Windows.Media;
    using System.Windows.Media.Animation;

    public partial class HideButtonBehavior : Behavior<FrameworkElement>
    {
        #region Custom Button Behavior

        protected override void OnAttached()
        {
            base.OnAttached();
            Button button = this.AssociatedObject as Button;
            button.RenderTransform = new ScaleTransform();
            button.MouseMove += button_MouseMove;
        }

        protected override void OnDetaching()
        {
            Button button = this.AssociatedObject as Button;
            button.MouseMove -= button_MouseMove;
            base.OnDetaching();
        }

        void button_MouseMove(object sender, MouseEventArgs e)
        {
            DoubleAnimationUsingKeyFrames anim = new DoubleAnimationUsingKeyFrames();
            anim.KeyFrames.Add(new LinearDoubleKeyFrame() { Value = 0.0, KeyTime = TimeSpan.FromMilliseconds(150) });
            anim.KeyFrames.Add(new LinearDoubleKeyFrame() { Value = 0.0, KeyTime = TimeSpan.FromMilliseconds(2000) });
            anim.KeyFrames.Add(new LinearDoubleKeyFrame() { Value = 1.0, KeyTime = TimeSpan.FromMilliseconds(2150) });

            Storyboard.SetTarget(anim, this.AssociatedObject);
            Storyboard.SetTargetProperty(anim, new PropertyPath("(UIElement.RenderTransform).(ScaleTransform.ScaleY)"));

            Storyboard sb = new Storyboard();
            sb.Children.Add(anim);
            sb.Begin();
        }
        #endregion

    }
}

Acknowledgements

This technique is first discovered by julmar

• Start to slide the toaster into view, then fade it out, and remove the toaster from visual tree
• If a mouse enters the toaster, then pause the sliding, and pause the fading out, and fade it in. Also, wait for mouse to leave
• When mouse leaves, resume sliding toaster, and fade out the toaster.

        private void rxPop()
        {
            Rectangle toaster = (Rectangle)this.FindName("toaster1");
            Thickness newToasterPosition = new Thickness(
                 toaster.Margin.Left, toaster.Margin.Top,
                 toaster.Margin.Right, toaster.Margin.Bottom + toaster.Height);

            /* Animations */
            Storyboard slideInAnimation = slideTo(toaster,
                newToasterPosition,
                TimeSpan.FromMilliseconds(450));

            Storyboard fadeInAnimation = animateOpacity(toaster, 1.0, TimeSpan.FromMilliseconds(150));

            Storyboard fadeOutAnimation = animateOpacity(toaster, 0.0, TimeSpan.FromSeconds(3));
            
            /* Events */
            var mouseEnter = Observable.FromEventPattern<MouseEventHandler, MouseEventArgs>
                (h => toaster.MouseEnter += h,
                 h => toaster.MouseEnter -= h);

            var mouseOut = Observable.FromEventPattern<MouseEventHandler, MouseEventArgs>
                (h => toaster.MouseLeave += h,
                 h => toaster.MouseLeave -= h);            

            /* Business logic: mouseEnter/mouseLeave should pause/restart animations */
            var mouseEnterSubscription = mouseEnter
                .ObserveOnDispatcher()
                .Do(mouseEnterEventArgs =>
                {
                    fadeOutAnimation.Pause();
                    fadeInAnimation.Begin();
                    slideInAnimation.Pause();
                })
                .Select(e => mouseOut)
                .Switch()
                .Do(mouseLeaveEventArgs =>
                {
                    fadeOutAnimation.Begin();
                    fadeInAnimation.Stop();
                    slideInAnimation.Resume();
                })
                .Subscribe();

            /* Business logic: slideIn then fadeOut then remove from visual tree */
            slideInAnimation
                .BeginUntilDone()
                .Select(slideInCompletedEvent =>
                    fadeOutAnimation.BeginUntilDone())
                .Switch()
                .Subscribe(fadeOutAnimationCompletedEvent =>
                {
                    mouseEnterSubscription.Dispose();

                    // remove from visual tree
                    (toaster.Parent as Panel).Children.Remove(toaster);
                });

        }

        private Storyboard slideTo(FrameworkElement toaster, Thickness newMargin, TimeSpan duration)
        {
            DoubleAnimation slide = new DoubleAnimation()
            {
                From = newMargin.Bottom - toaster.Margin.Bottom,
                To = 0.0,
                Duration = duration,
            };
            toaster.Margin = newMargin;
            Storyboard.SetTarget(slide, toaster);
            Storyboard.SetTargetProperty(slide,
                new PropertyPath("(UIElement.RenderTransform).(TranslateTransform.Y)"));
            Storyboard slideboard = new Storyboard();
            slideboard.Children.Add(slide);
            return slideboard;
        }

        private Storyboard animateOpacity(FrameworkElement toaster, double target, TimeSpan duration)
        {
            DoubleAnimation fade = new DoubleAnimation()
            {
                To = target,
                Duration = duration,
            };

            Storyboard.SetTarget(fade, toaster);
            Storyboard.SetTargetProperty(fade,
                new PropertyPath("Opacity"));
            Storyboard slideboard = new Storyboard();
            slideboard.Children.Add(fade);
            return slideboard;
        }

    public static class RxExtensions
    {
        public static IObservable<EventPattern<EventArgs>> BeginUntilDone(this Storyboard sb)
        {
            var tmp = Observable.FromEventPattern(
                h => sb.Completed += h,
                h => sb.Completed -= h);
            sb.Begin();
            return tmp;
        }
    }

To avoid this, we can use Assembly Library Caching. However, this is not always ideal. Each of the projects might be only a tiny DLL, and it is a lot of work. Each change in version number will require the .extmap.xml be updated. Furthermore, if we don’t change the version number, we might end up with Silverlight loading an older version, and we end up with “Symbol not loaded” in the debugger.

There is an alternative.

1. Since we typically work on one assembly at a time, set all the assemblies we don’t care about to CopyLocal=False
2. Then, (optional) in the Configuration Manager, uncheck the “Build” option for these DLLs as well.
3. Next, zip up these DLLs, let’s call it library.zip. It should not have any directory structure at all e.g.
   
mylibrary01.dll
mylibrary02.dll

4. Then in the Properties/AppManifest.xml of the main project, add the following entry

   <Deployment xmlns="http://schemas.microsoft.com/client/2007/deployment"
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
       <Deployment.Parts>
       </Deployment.Parts>
     <Deployment.ExternalParts>
       <ExtensionPart Source="library.zip"/>
     </Deployment.ExternalParts>  
   </Deployment>
   

5. You are done.

When you start up this project, you’ll notice that compiling can be very fast, as xapping will skip all the files that have CopyLocal=false.

Russian prosecutors sought 3 years of jail term for this act of political defiance by Pussyriot. Aaron Swartz was threatened with 35.

There were a few problems along the way.

Clojure reports MethodNotFound

Leiningen already contains Clojure 1.2.1. If we intend to run Clojure 1.4, it has to appear on the classpath first. However, when Launch4j wraps a leiningen-standalone.jar, it is the first file that appears on the classpath. The solution is to specify clojure-1.4.0.jar as the main jar.

Launch4j couldn’t find clojure.jar

The documentation was incorrect. The location of the jar files were incorrectly stated to be relative to the exe file. In practice, the executable directory must be explicitly included. e.g. %EXEDIR%\clojure-1.4.0.jar

Other tricks

I was able to wrap clojure.jar into clojure.exe, which performs double-duty as a .jar file. I was able to include clojure.exe into the classpath to save disk space.

Download launch4j-clojure.zip

<launch4jConfig>
  <dontWrapJar>true</dontWrapJar>
  <headerType>console</headerType>
  <jar>%EXEDIR%\clojure.exe</jar>
  <outfile>lein.exe</outfile>
  <errTitle></errTitle>
  <cmdLine>clojure.main -e "(use &apos;leiningen.core)(-main)" %@</cmdLine>
  <chdir></chdir>
  <priority>normal</priority>
  <downloadUrl>http://java.com/download</downloadUrl>
  <supportUrl></supportUrl>
  <customProcName>false</customProcName>
  <stayAlive>false</stayAlive>
  <manifest></manifest>
  <icon></icon>
  <classPath>
    <mainClass>jline.ConsoleRunner</mainClass>
    <cp>%EXEDIR%\leiningen-1.7.0-standalone.jar</cp>
  </classPath>
  <jre>
    <path></path>
    <minVersion>1.5.0</minVersion>
    <maxVersion></maxVersion>
    <jdkPreference>preferJre</jdkPreference>
    <opt>-client </opt>
    <opt>-XX:+TieredCompilation</opt>
  </jre>
</launch4jConfig>

For example, you cannot use PyFile_AsFile, the reason is that C runtime objects like FILE* created in one runtime e.g. msvcrt.dll cannot be used in another, e.g. msvcrt70.dll

In addition, malloc() allocated memory from one runtime cannot be freed from another runtime.

Here’s a rundown:

• Potential Errors Passing CRT Objects Across DLL Boundaries
• Also read PEP 384 – maintaining a stable ABI, where it mentions
  

  In addition, functions expecting FILE* are not part of the ABI, to avoid depending on a specific version of the Microsoft C runtime DLL on Windows.

Interestingly, there are techniques called forwarder DLLs that redirect DLL calls to another version.

• See Exported functions that are really forwarders.
• DLL forwarding in Python (StackOverflow).

More interestingly though is the possibility of using Visual Studio to link against the older runtime directly

• linking against the old MSVCRT with newer versions of visual studio, also
• Dynamically linking with MSVCRT.DLL using Visual C++ 2005.

#1

Cheat sheets

FXML

((Scene)FXMLLoader.load(getClass().getResource("fxml_tableview.fxml"))

// to get controller
FXMLLoader loader = new FXMLLoader(getClass().getResource("fxml_tableview.fxml"));
(Scene) loader.load();
(MyController) loader.getController();

Stylesheets

JavaFX Stylesheets have to be set programmatically, not declaratively.

scene.getStylesheets().add("/resources/shell.css");

ItemsSource binding

ListView has an ObservableList itemsProperty whereupon invalidated() calls

if (getSkin() instanceof ListViewSkin) {
  ListViewSkin<?> skin = (ListViewSkin<?>) getSkin();
  skin.updateListViewItems();
}