I somehow convinced myself that wrapping an “internal” exception in a public/”external” API service-level exception would ensure that client would only be dependent on the external exception. Wrong!

Certainly not when I did the sensible (?) thing of preserving the cause of the exception – that being the internal exception:

try {
   doSomethingThatMightThrowAnInternalException();
} catch (InternalException e) {
   throw new ExternalException("A useful message.",e);
}

The “,e);” is the culprit in the above code snippet.

My SOA service is offered as an RMI service as well as a web service. I provide a client jar containing all the public API classes (interfaces and exceptions) but no internal implementation classes. If the internal exception occurs though, then a ClassNotFoundException will occur when unmarshalling the external exception, because it has-a(n) internal exception.

java.lang.ClassNotFoundException: com.my.InternalException
(no security manager: RMI class loader disabled)

Now this wouldn’t happen if dynamic class loading were in use, but in this instance, it isn’t.

Three solutions are open now:

• Add the internal exception to the client interface jar.
• Don’t wrap the internal exception, but instead throw a new external exception without a cause.
• Turn on dynamic class loading by enabling the RMI class loader.

Like I say, school boy error. We live and learn (or at least remember).

This is something I’ve come up against many times on my most recent project.

http://www.jakubkorab.net/2009/10/a-better-builder.html

My thoughts:

Sharing your home directory will break your error highlighting within Intellij. Your code will build/make so long as you have configured your JDK (JSDK) correctly, but will fail to find core Java language types such as String within the editor.

Save yourself many hours and uncheck the option in Parallels to share your home directory.

See the final comment in this chain for further details: Error highlighting is flagging my Java types “cannot resolve symbol” even tho compile & run works.

EXCEPTION_ACCESS_VIOLATION

If you get the following, kill all of your JVMs and try again. Simple as. Grrrr… Big red hearing when you’ve just changed a load of code.

EXCEPTION_ACCESS_VIOLATION (0xc0000005) at

Thanks to http://www.java-forums.org/eclipse/312-exception_access_violation-0xc0000005.html for this.

OSGi Bundles and Native Code

Be warned, configuring native code within an OSGi bundle manifest isn’t obvious or intuitive.

This looks like it works, but it doesn’t … and it fails silently, even though if I added some nonsense entry, it would complain.

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: My Cool Plug-in
Bundle-SymbolicName: com.figmentweb.cool;singleton:=true
Bundle-Version: 1.0.0
Bundle-Activator: com.figmentweb.cool.Activator
Bundle-Vendor: DKIB
SpringContext: OSGI-INF/importexport.xml,
 spring/cool/application-context.xml,
 spring/client/cool/cool-beans.xml
Require-Bundle: org.eclipse.core.runtime,
 org.eclipse.ui;bundle-version="3.4.1"
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Bundle-NativeCode: dll/a.dll,
 dll/b.dll,
 dll/c.dll,
 dll/d.dll,
 dll/e.dll,
 dll/f.dll,
 dll/g.dll,
 dll/h.dll
Bundle-ClassPath: ...

This is what it should be:

Manifest-Version: 1.0
Bundle-ManifestVersion: 2
Bundle-Name: My Cool Plug-in
Bundle-SymbolicName: com.figmentweb.cool;singleton:=true
Bundle-Version: 1.0.0
Bundle-Activator: com.figmentweb.cool.Activator
Bundle-Vendor: DKIB
SpringContext: OSGI-INF/importexport.xml,
 spring/cool/application-context.xml,
 spring/client/cool/cool-beans.xml
Require-Bundle: org.eclipse.core.runtime,
 org.eclipse.ui;bundle-version="3.4.1"
Bundle-ActivationPolicy: lazy
Bundle-RequiredExecutionEnvironment: JavaSE-1.6
Bundle-NativeCode: dll/a.dll;
 dll/b.dll;
 dll/c.dll;
 dll/d.dll;
 dll/e.dll;
 dll/f.dll;
 dll/g.dll;
 dll/h.dll
Bundle-ClassPath: ...

That is, even though every other multi-entry/list of configurations is split across lines by ‘,’ – within the Bundle-NativeCode we should use ‘;’. Using ‘,’ won’t cause an error, it just means that only the first DLL is loaded.

The ability to bundle DLLs/SOs into a bundle jar is awesome though.

Thanks to: http://www.eclipse.org/newsportal/article.php?id=12052&group=eclipse.platform.rcp#12052

What began as a fairly straight forward learning exercise encompassing mathematics, financial concepts and a bit of C++ programming managed to dissolve into an endurance test towards the end. As the course progressed, week by week more comrades fell by the way side, beaten into submission by Ito’s Lemma, Partial Differential Equations or some other abstract mathematical concept. Worryingly, to even survive the 10 week course and serve a full tour of duty made me feel like I’d achieved something. By the end of the course the class size had reduced to a third, of which I suspect even fewer submitted any programming assignment solutions.

Each of the four programming assignments was allocated on a Tuesday and due by the following Friday. This meant getting as much done on the assignment over that coming weekend in preparation for the next class. After the first assignment had been allocated, it became the norm that the 10 minute break in each class be (ab)used as an intense assignment inquest by students.

Our assignments were as follows:

• Project 1: Bootstrapping the Yield Curve
  • Write a C++ program which will generate a continuous zero curve calibrated to price correctly the specified bonds.
• Project 2: Binomial Tree Pricing
  • Price the specified European-style vanilla call option with a tree.
  • Modify your program to price the corresponding American option.
• Project 3: Monte Carlo Pricing
  • Price the specified European-style vanilla put option using Monte Carlo.
  • Modify your program to work with Payoff classes handling vanilla call, vanilla put, digital call and digital put payoffs.
• Project 4: Exotic Option Monte Carlo Pricing
  • Price a European-style put option that gives the holder the right to sell the more expensive of two correlated stocks.
  • Price the option as a fixed strike lookback.

This is where the course made a big difference for me and where I believe its strength and value lie. Learning theory is all well and good, and the theory was taught as well as it could be, but it is incredibly dry. However, applying this theory and building a pricing model was nothing short of exciting.

Project 2 was the turning point for me. I had a great experience with the assignment and received positive feedback, which really spurred me on for later assignments. Project 2 was of particular interest to me after working on the Loan Pricing Service, which used a Binomial Option Pricing Model (BOPM). While Paul Wilmott might not think much of it, I enjoyed it and I think it provides a solid foundation for more advanced models.

Particularly in the last two assignments (which were combined into a single assignment due to time limits), I really had to work hard to reach the desired solution which employed discrete and continuous time models, as well as working with correlated dividend paying stocks.

Ironically, Hull – a book I’d delved into from time-to-time over the past few years – became a lot more readible and accessible during the course.  It became my main reference and seemed to provide everything I needed. It’s funny how a book which once scared me soon became my bible. I guess everything is relative: university slides of pure notation versus vaguelly human-readable text.

From my blog stats I’ve noticed that often people google* using keywords like “C#” “inverted index” “java” and select this blog as a result.

* I say “google”, but really I mean generic web searching.

Inverted Index

Since there isn’t much direct information about inverted indexes (indices?) here, I thought I should at least provide some information for those surfers I’m capturing – perhaps incorrectly – due to the blog’s URL.

An inverted index, also known as an inverted file, is a data structure central to text-based information retrieval. The name is derived from the structure’s design and purpose, which in its simplist form is a map of key-value pairs:

• Key: The map is keyed by tokens, which can be a word, such as “dog” or “plate”, or some other code (perhaps a part of a word) depending on the granularity of the index.

• Value: The value in the map is a list of postings, sometimes stored as a separate file on the filespace and called a Postings File.

The inverted index is the output of the indexing process. The input to this process is a collection of documents of texts, often referred to in IR terms as a corpus.

Example

For example, given the following documents…

Document 1

The cat sat on the mat.

Document 2

The quick brown fox jumps over the lazy dog.

Indexing documents 1 and 2 without employing any stopword removal or stemming would produce the following index…

  {brown} -> {2}
  {cat}   -> {1}
  {dog}   -> {2}
  {fox}   -> {2}
  {jumps} -> {2}
  {mat}   -> {1}
  {on}    -> {1}
  {over}  -> {2}
  {quick} -> {2}
  {sat}   -> {1}
  {the}   -> {1,2}

This index only stores within the posting list the ID of the document a token is present in. It doesn’t indicate how often a token occurs within a document, where it appears within a document or how long a document is (for normalisation purposes).

None-the-less, even an index of such simple form can answer the question “which documents contain the words ‘quick’ ‘dog’ and ‘the’?”. It does not, however, answer (or support answering) the real question we want to ask, “which documents are about <subject>?”, very accurately.

Further Reading

The following links will provide some useful information on the subject matter:

• Introduction to Information Retrieval – free online text from Manning, Raghavan (of Yahoo! Research) and Schütze. An excellent book from members of the IR community working in both academia and industry.

• Information Retrieval – free online text of a book by Dr. CJ van Rijsbergen of the University of Glasgow covering advanced topics in Information Retrieval. A classic text and a great introduction.

Final Thoughts

And the last question: why have I named this blog inverted index? See: about.

This short how-to will show you how to create a menu as part of a Microsoft Visual Studio Tools for Office (VSTO) Excel 2003 Add-In.

It is assumed that you have Microsoft Visual Studio and the Microsoft Visual Studio Tools for Office SDK installed. The project in this tutorial was created using Microsoft Visual Studio 2008, developing with C#.

Create a new Project

If you have an existing VSTO Excel add-in project you want to add a menu to, skip to the next section.

Otherwise:

1. Open Microsoft Visual Studio.
2. Select File > New > Project.
3. From the New Project window select Visual C# > Office > 2003. (If you can’t see the Office branch of the Visual C# tree, you don’t have VSTO installed).
4. Select Excel 2003 Add-in.
5. Name the add-in project ExcelAddIn1.
6. Click OK.
7. Open the ThisAddIn.cs file.

Using Statements

It is assumed throughout this tutorial that the following using statements are present:

using Excel = Microsoft.Office.Interop.Excel;
using Office = Microsoft.Office.Core;

These are normally automatically generated by the VSTO project.

Add-In Callbacks

It is assumed that you have something similar to the following in your Excel Add-In code file, named for example ThisAddIn.cs:

private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
   #region VSTO generated code
   this.Application = (Excel.Application)
      Microsoft.Office.Tools.Excel.ExcelLocale1033Proxy.Wrap(
         typeof(Excel.Application), this.Application);
   #endregion
}
...
private void ThisAddIn_Shutdown(object sender, System.EventArgs e) { }
...
#region VSTO generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InternalStartup()
{
   this.Startup += new System.EventHandler(ThisAddIn_Startup);
   this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
}
#endregion

Member Fields

Create the following member fields in your ThisAddIn.cs:

public partial class ThisAddIn
{
   ...
   private Office.CommandBarPopup popupMenu;
   private Office.CommandBarButton menuCommand;
   ...
}

Add Menu Method

Add the following method to your ThisAddIn.cs:

private void AddMenuBar()
{
   try
   {
      Office.CommandBar activeMenuBar = (Office.CommandBar)
         Application.CommandBars.ActiveMenuBar;
      int controlCount = activeMenuBar.Controls.Count;

      popupMenu = (Office.CommandBarPopup)
         activeMenuBar.Controls.Add(
            Office.MsoControlType.msoControlPopup,
            missing,
            missing,
            controlCount,
            true);

      if (popupMenu != null)
      {
         popupMenu.Caption = "&My Menu";

         menuCommand = (Office.CommandBarButton)
            popupMenu.Controls.Add(
               Office.MsoControlType.msoControlButton,
               missing,
               missing,
               missing,
               true);

         menuCommand.Caption = "&Do Something";
         menuCommand.FaceId = 59;

         menuCommand.Click +=
            new Office._CommandBarButtonEvents_ClickEventHandler(
               menuCommand_Click);
      }
   }
   catch (Exception e)
   {
      MessageBox.Show(e.Message);
   }
}

The first line gets a reference to the active menu bar. The method then uses this to create and add a menu to the menu bar with the caption “My Menu”. The newly created menu is assigned to the popupMenu member field. Notice that true is passed into the last variable of the Controls.Add() method – this specifies that the menu is a temporary object. By specifying that the menu is temporary, it will automatically be removed from Excel when the add-in is closed, either implicitly by closing Excel or by forceably removing the add-in. The benefit of this is that you don’t need to write any code to explicitly remove the menu.

A menu item (CommandBarButton) is then created using the previously created menu’s Controls.Add() method. The button is assigned to the menuCommand member field. A caption is set – this it the text visible in the menu item. The FaceId specifies an icon to display as part of the menu item (to the left of the menu item caption) which can be one of these FaceIds. Notice again that true is specified for the temporary argument of the Controls.Add() method.

An event handler is wired up to the menu button’s click event, which calls method menuCommand_Click (below).

Note: Your code won’t compile until you follow the next step.

Event Handler Method

Add the following method to your ThisAddIn.cs:

private void menuCommand_Click(Office.CommandBarButton Ctrl, ref bool CancelDefault)
{
   MessageBox.Show("Menu Command Click!");
}

This is the event handler wired up to the menu item click. It simply displays a message to the user each time the menu item is clicked.

Note: Your code should now compile.

Installing the Menu

If you run the add-in now, you will notice that the menu does not appear in the main menu bar as desired. We must tell the add-in to add the menu. To do this, modify the startup callback of your ThisAddIn.cs to match the following:

private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
   #region VSTO generated code
   this.Application = (Excel.Application)
      Microsoft.Office.Tools.Excel.ExcelLocale1033Proxy.Wrap(
         typeof(Excel.Application), this.Application);
   #endregion

   AddMenuBar();
}

That is, add the call to AddMenuBar() to the existing code.

Run the Add-In

Try running your project in debug mode. You should see a new menu with a single item like so:

Menu Screenshot

Clicking on the menu item will display the message box, as shown:

Message Box Screenshot

This short how-to will show you how to create a toolbar as part of a Microsoft Visual Studio Tools for Office (VSTO) Excel 2003 Add-In.

It is assumed that you have Microsoft Visual Studio and the Microsoft Visual Studio Tools for Office SDK installed. The project in this tutorial was created using Microsoft Visual Studio 2008, developing with C#.

Create a new Project

If you have an existing VSTO Excel add-in project you want to add a toolbar to, skip to the next section.

Otherwise:

1. Open Microsoft Visual Studio.
2. Select File > New > Project.
3. From the New Project window select Visual C# > Office > 2003. (If you can’t see the Office branch of the Visual C# tree, you don’t have VSTO installed).
4. Select Excel 2003 Add-in.
5. Name the add-in project ExcelAddIn1.
6. Click OK.
7. Open the ThisAddIn.cs file.

Using Statements

It is assumed throughout this tutorial that the following using statements are present:

using Excel = Microsoft.Office.Interop.Excel;
using Office = Microsoft.Office.Core;

These are normally automatically generated by the VSTO project.

Add-In Callbacks

It is assumed that you have something similar to the following in your Excel Add-In code file, named for example ThisAddIn.cs:

private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
   #region VSTO generated code
   this.Application = (Excel.Application)
      Microsoft.Office.Tools.Excel.ExcelLocale1033Proxy.Wrap(
         typeof(Excel.Application), this.Application);
   #endregion
}
...
private void ThisAddIn_Shutdown(object sender, System.EventArgs e) { }
...
#region VSTO generated code
/// <summary>
/// Required method for Designer support - do not modify
/// the contents of this method with the code editor.
/// </summary>
private void InternalStartup()
{
   this.Startup += new System.EventHandler(ThisAddIn_Startup);
   this.Shutdown += new System.EventHandler(ThisAddIn_Shutdown);
}
#endregion

Member Fields

Create the following member fields in your ThisAddIn.cs:

public partial class ThisAddIn
{
   ...
   private Office.CommandBar toolbar;
   private Office.CommandBarButton toolbarCommand;
   ...
}

Add Toolbar Method

Add the folloing method to your ThisAddIn.cs:

private void AddToolbar()
{
   try
   {
      toolbar = Application.CommandBars.Add(
         "My Toolbar",
         Office.MsoBarPosition.msoBarTop,
         false,
         true);
      if (toolbar != null)
      {
         toolbarCommand = (Office.CommandBarButton)
            toolbar.Controls.Add(
               Office.MsoControlType.msoControlButton,
               missing,
               missing,
               missing,
               true);
         toolbarCommand.Caption = "Toolbar Button";
         toolbarCommand.FaceId = 59;
         toolbarCommand.Click +=
            new Office._CommandBarButtonEvents_ClickEventHandler(
               toolbarCommand_Click);
         toolbar.Visible = true;
      }
   }
   catch (Exception e)
   {
      MessageBox.Show(e.Message);
   }
}

This method creates a new toolbar named “My Toolbar” and assigns it to the toolbar member field. Notice that true is passed into the last variable of the CommandBars.Add() method – this specifies that the toolbar is a temporary object. By specifying that the toolbar is temporary, it will automatically be removed from Excel when the add-in is closed, either implicitly by closing Ms Excel or by forceably removing the add-in. The benefit of this is that you don’t need to write any code to explicitly remove the toolbar.

A toolbar button is then created using the previously created toolbar’s Controls.Add() method. The button is assigned to the toolbarCommand member field. A caption is set – this will be displayed when the user hovers their mouse over the toolbar button. The FaceId specifies the toolbar button icon – which can be one of these FaceIds. Notice again that true is specified for the temporary argument of the Controls.Add() method.

An event handler is wired up to the toolbar button’s click event, which calls method toolbarCommand_Click (below).

This code has created the toolbar, but it will not be visible to the user unless explicitly instructed. Without setting the toolbar to visible here, the user would have to right click on the toolbar area and select the toolbar from a list of those available.

Note: Your code won’t compile until you follow the next step.

Event Handler Method

Add the following method to your ThisAddIn.cs:

private void toolbarCommand_Click(Office.CommandBarButton Ctrl, ref bool CancelDefault)
{
   MessageBox.Show("Toolbar Command Click!");
}

This is the event handler wired up to the toolbar button click. It simply displays a message to the user each time the toolbar button is clicked.

Note: Your code should now compile.

Installing the Toolbar

If you run the add-in now, you will notice that the toolbar is not installed by the add-in. We must tell the add-in to add the toolbar. To do this, modify the startup callback of your ThisAddIn.cs to match the following:

private void ThisAddIn_Startup(object sender, System.EventArgs e)
{
   #region VSTO generated code
   this.Application = (Excel.Application)
      Microsoft.Office.Tools.Excel.ExcelLocale1033Proxy.Wrap(
         typeof(Excel.Application), this.Application);
   #endregion

   AddToolbar();
}

That is, add the call to AddToolbar() to the existing code.

Run the Add-In

Try running your project in debug mode. You should see a new toolbar with a single button like so:

Toolbar Screenshot

Clicking on the toolbar button will display the message box, as shown:

Message Box Screenshot

Windows Services are most suited to long-running, non-interactive processes. For example, a stand-alone server application that doesn’t run within a web or EJB container, such as a Spring or Core Java SE application.

The Java Services Wrapper from Tanuki Software provides a simple way to install a Java application as a Windows service. It also simplifies installation of the same Java application as  a daemon process on Unix systems.

I’ve used the wrapper for some time now to wrap an SOA application. It’s easy to use, configure and deploy.