Tag Archives: finance

The Black Scholes Algorithm: The Greeks in Java

Last time in the Black Scholes series I wrote about how to write the Black Scholes algorithm in Java in a maintainable and readable way by decomposing its constituent parts for easy reference. This time I look at modifying the previous implementation to incorporate The Greeks. Though – this time – there’s isn’t any great degree of decomposition to do as each Greek has its own formula and each one is implemented separately anyway.

What are The Greeks and how do they relate to the Black Scholes algorithm? This is best answered by Risk Glossary. Below I merely present a decomposed implementation of Black Scholes and The Greeks. In terms of performance considerations I’ve ensured that no equivalent operations are called more than once. I’ve also eliminated object allocation completely – the only allocation made is of a result array which contains six doubles. However, I have not applied advanced optimisations such as the use of multiplication in place of the pow() function.

I want to add a disclaimer that there isn’t anything very new in this post that isn’t already out there. I’m sure this has been done lots of times out there but I’m posting this for two reasons: 1) I wanted to post my take on the implementation in a decomposed fashion 2) I didn’t really find anything out there implementing the Greeks in Java. I hope it helps others looking for something similar.

The Greeks in Java

The inputs to the The Greeks formulas are the same as those available to the The Black Scholes algorithm so both can implemented in common scope. Most Greeks have different formulas for call and put options with the exception of gamma and vega which have been implemented common to call and put options. Theta was the most complex formula compared to the rest of them and so I’ve broken that one down into left and right halves. The calculate() method returns a six element double array which contains the following values in order: (1) price (2) delta (3) gamma (4) vega (5) theta (6) rho. If you want to know what the inputs are see my previous article and for the formulas implemented below look here.

package name.dhruba.black.scholes;

import static java.lang.Math.PI;
import static java.lang.Math.abs;
import static java.lang.Math.exp;
import static java.lang.Math.log;
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public enum BlackScholesGreeks2 {

    _;

    private static final double P = 0.2316419;
    private static final double B1 = 0.319381530;
    private static final double B2 = -0.356563782;
    private static final double B3 = 1.781477937;
    private static final double B4 = -1.821255978;
    private static final double B5 = 1.330274429;

    public static double[] calculate(boolean c, 
            double s, double k, double r, double t, double v) {

        double[] p = new double[6];

        double d1 = d1(s, k, r, t, v);
        double d2 = d2(s, k, r, t, v);
        
        double sd1 = standardNormalDistribution(d1);
        double cd1 = cumulativeDistribution(d1, sd1);
        double thetaLeft = -(s * sd1 * v) / (2 * sqrt(t));

        if (c) {

            double cd2 = cumulativeDistribution(d2);

            // price
            p[0] = s * cd1 - k * exp(-r * t) * cd2;

            // delta
            p[1] = cd1;

            // theta
            double thetaRight = r * k * exp(-r * t) * cd2;
            p[4] = thetaLeft - thetaRight;

            // rho
            p[5] = k * t * exp(-r * t) * cd2;

        } else {

            double pcd1 = cumulativeDistribution(-d1);
            double pcd2 = cumulativeDistribution(-d2);

            // price
            p[0] = k * exp(-r * t) * pcd2 - s * pcd1;

            // delta
            p[1] = cd1 - 1;

            // theta
            double thetaRight = r * k * exp(-r * t) * pcd2;
            p[4] = thetaLeft + thetaRight;

            // rho
            p[5] = -k * t * exp(-r * t) * pcd2;

        }

        // gamma
        p[2] = sd1 / (s * v * sqrt(t));

        // vega
        p[3] = s * sd1 * sqrt(t);

        return p;

    }

    private static double d1(double s, double k, double r, double t, double v) {
        double top = log(s / k) + (r + pow(v, 2) / 2) * t;
        double bottom = v * sqrt(t);
        return top / bottom;
    }

    private static double d2(double s, double k, double r, double t, double v) {
        return d1(s, k, r, t, v) - v * sqrt(t);
    }

    public static double cumulativeDistribution(double x) {
        return cumulativeDistribution(x, standardNormalDistribution(x));
    }

    public static double cumulativeDistribution(double x, double sdx) {
        double t = 1 / (1 + P * abs(x));
        double t1 = B1 * pow(t, 1);
        double t2 = B2 * pow(t, 2);
        double t3 = B3 * pow(t, 3);
        double t4 = B4 * pow(t, 4);
        double t5 = B5 * pow(t, 5);
        double b = t1 + t2 + t3 + t4 + t5;
        double cd = 1 - sdx * b;
        return x < 0 ? 1 - cd : cd;
    }

    public static double standardNormalDistribution(double x) {
        double top = exp(-0.5 * pow(x, 2));
        double bottom = sqrt(2 * PI);
        return top / bottom;
    }

}

Testing the implementation

I’ve written a simple test based on values assumed to be correct from an online calculator. Rather oddly for some of the values although my answers matched with that online calculator they differ from those on Wolfram Alpha very slightly. I don’t know why Wolfram Alpha is produced different values. If you know let me know.

package name.dhruba.black.scholes;

import static org.junit.Assert.assertEquals;

import org.junit.Test;

public class TestBlackScholesGreeks {

    @Test
    public void testGreeks() {

        boolean c;
        double s, k, r, t, v;
        double[] p;

        c = true;
        s = 56.25;
        k = 55;
        r = 0.0285;
        t = 0.34;
        v = 0.28;

        p = BlackScholesGreeks2.calculate(c, s, k, r, t, v);

        assertEquals(4.561, round(p[0], 3), 0);
        assertEquals(0.610, round(p[1], 3), 0);
        assertEquals(0.042, round(p[2], 3), 0);
        assertEquals(12.587, round(p[3], 3), 0);
        assertEquals(-6.030, round(p[4], 3), 0);
        assertEquals(10.110, round(p[5], 3), 0);

        c = false;
        p = BlackScholesGreeks2.calculate(c, s, k, r, t, v);

        assertEquals(2.781, round(p[0], 3), 0);
        assertEquals(-0.390, round(p[1], 3), 0);
        assertEquals(0.042, round(p[2], 3), 0);
        assertEquals(12.587, round(p[3], 3), 0);
        assertEquals(-4.478, round(p[4], 3), 0);
        assertEquals(-8.409, round(p[5], 3), 0);

    }

    static double round(double d, int places) {
        int factor = (int) Math.pow(10, places);
        return (double) Math.round(d * factor) / factor;
    }

}

Oddities

One thing I noticed is that for the price formula for a put option reordering certain operations, even though the overall operation was equivalent, produced different digits towards the end of the value; in other words, towards the final decimal places. The following two operations, for example, although equivalent, produce different digits for the final few decimal places. If anyone knows what’s going on here do let me know.

p[0] = pcd2 * k * exp(-r * t) - pcd1 * s;
p[0] = k * exp(-r * t) * pcd2 - s * pcd1;

Did this help you or do you have any improvements or fixes? Let me know in the comments.

The Black Scholes Algorithm: A decomposed implementation in Java

Recently, I had to get to grips with the Black Scholes algorithm and its implementation in a few different languages. I decided to go with Java first as that’s what I’m most proficient at. The objective here was to code the algorithm from scratch rather than use a third party library and remain in ignorance.

A critique of existing Black Scholes implementations in Java

Like any good programmer I first searched to see what was out there. I found numerous such questions on the web as well as only three implementations in Java. The first was Espen Haug’s authoritative webpage implementing Black Scholes in a number of different languages. Espen Haug is known for his two books: The Complete Guide to Option Pricing Formulas and Derivatives: Models on Models; the second – a teaching resource implementation by Robert Sedgewick and Kevin Wayne and third, an implementation by Joshua Davis on koders.com.

To be quite frank I wasn’t happy with any of these implementations. The third implementation was identical to the first one. The second implementation appeared only to support call option prices. And they all exhibited, in my opinion, classic signs of bad code. Let me be more specific by taking Espen Haug’s implementation as an example though many of my reservations would apply to the others too.

Espen Haug’s program, first of all, was written exactly as you would write a C or C++ program; more like C actually. I don’t think it could have been any further from idiomatic Java. First of all it was syntactically incomplete. It was composed only of two functions not residing within a class. The casing of the function and variable naming was arbitrary and not like that of Java at all. The lack of whitespacing and indenting made it all the more hard to read and the constant declarations within the second method invocation was just sheer laziness. I couldn’t help but get the impression that if it had been possible to put the whole thing on one line the author would have.

So far, you could argue, though I would refute it, that my criticisms have been synthetic but if you were to do so you would have spoken too soon. My biggest objection, by far, is still to come and it is I believe a fundamental problem that makes these implementations unacceptable to me. It is the fact that none of the implementations give the reader any idea of how they’ve been composed. To put it another way – although the implementations may be correct and the authors far more intelligent than I – the programs have not been decomposed into their constituent parts for the benefit of the reader’s comprehension. And for this reason there’s insufficient reuse of certain code. For example, if there was a function for the standard normal probability function (which is bundled into the CND() code) then it would be reused by the CND() function as well as the calculation of the Greeks.

The existing implementations may be suitable if I was just looking to copy and paste some code and not care about what it did or its maintainability and readability. However, in this case, I was looking to learn about the algorithm itself from these sources and wanted to know specifically how the implementations had been composed from the formulas and to which areas of code each constituent formula corresponded. In the ideal case I should have been able to look at the formulas and the implementation side by side and be able to relate one to the other by merely identifying blocks of code. I knew I could do better so I did.

A decomposed implementation

Here I present the constituent parts in the implementation of the Black Scholes algorithm and formulas that correspond to each part – an end result I refer to as a decomposed implementation. This is purely the derivation of an implementation from the mathematical formulas. It is NOT a discussion about the mathematical or financial aspects of the algorithm – this I’m simply not qualified to write about. Please see expert authors if you’re looking for a semantic treatment.

Black Scholes Formula

The Black Scholes formula prices European call or put options and consists, at the top level, of two formulas – one that calculates the price of a call option (c) and another calculates the price of a put option (p).

where:

The meanings of the variables used above are as below.

  • s = price of stock
  • x = strike price
  • r = risk free interest rate
  • t = time in years until option expiration
  • σ (sigma) – implied volatility of stock
  • Φ (phi) – standard normal cumulative distribution function

In order to implement these formulas let’s take our first step in decomposing it. So far the formula above consists almost entirely of scalar primitive variables with the exception of one: Φ (phi). This is the standard normal cumulative distribution function (CDF). As it is a prerequisite to the formulas it must be implemented first. Let’s look at the CDF formula.

The CDF is not used directly in Black Scholes being an infinite integral. Instead a very accurate numerical approximation method is used. There are a number of different ways CDF can be approximated depending on the level of accuracy desired. In Black Scholes generally the Abramowitz & Stegun (1964) numerical approximation is used which is given below.

The Abramowitz & Stegun numerical approximation above uses six constant values in its formula. However it also relies on another function in turn – the standard normal probability density function (PDF) denoted above by Z(x). We will return to implement the CDF later but we must drop down another step in our decomposition to implement the PDF which is our lowest level prerequisite.

Standard normal probability density function

The standard normal probability density function (PDF) is as below.

As you can see the PDF is defined purely in terms of variables and there are no further functions involved so let’s begin our Java implementation with this formula.

    public static double standardNormalDistribution(double x) {
        double top = exp(-0.5 * pow(x, 2));
        double bottom = sqrt(2 * PI);
        return top / bottom;
    }

Note that even the implementation of this function is decomposed into its top half and its bottom half allowing it be easily related to the formula above visually by the reader. This is how I prefer formulas to be coded. Now that we’ve implemented the PDF let us return to the next function up which required the PDF: the CDF.

Standard normal cumulative distribution function

As we discussed previously the CDF implementation uses the Abramowitz & Stegun (1964) numerical approximation formula consisting of six constant values as below.

Since we now have a PDF implementation above we can now use this in our CDF Java implementation below. This implements the CDF with one little difference: on line 9 and 17 it handles negative values appropriately. On line 16 we use the PDF function defined earlier on.


    private static final double P = 0.2316419;
    private static final double B1 = 0.319381530;
    private static final double B2 = -0.356563782;
    private static final double B3 = 1.781477937;
    private static final double B4 = -1.821255978;
    private static final double B5 = 1.330274429;

    public static double cumulativeDistribution(double x) {
        double t = 1 / (1 + P * abs(x));
        double t1 = B1 * pow(t, 1);
        double t2 = B2 * pow(t, 2);
        double t3 = B3 * pow(t, 3);
        double t4 = B4 * pow(t, 4);
        double t5 = B5 * pow(t, 5);
        double b = t1 + t2 + t3 + t4 + t5;
        double cd = 1 - standardNormalDistribution(x) * b;
        return x < 0 ? 1 - cd : cd;
    }

Once again, note the nature of the code above. The function and variables are named appropriately with the variable naming being the same as in the formula, each step of the formula is broken down into a separate line and constants are declared separately and not inline. And the code is again easy to relate to the formula. Let us now move to the next function implementation required by the Black Scholes formula. This time, it is not one, but two: d1 and d2. Let’s look at d1 first. Now, bear in mind, although d1 and d2 do not require the CDF directly the Black Scholes formula does so that’s why we looked at CDF first. Though – we could also have looked at d1 and d2 first. It would have been an equally valid decomposition.

d1 – A sub-formula of Black Scholes

The d1 formula is as follows which I reproduce here again for convenience.

Before I present the d1 Java implementation here is the legend of the variable names used which are mostly substitutions of the greek letters used in the maths formula.

  • s = Spot price of underlying stock/asset
  • k = Strike price
  • r = Risk free annual interest rate continuously compounded
  • t = Time in years until option expiration (maturity)
  • v = Implied volatility of returns of underlying stock/asset

Here is the Java implementation of d1 using the names above. Once again note the formula is broken down into regions which makes it easy to relate to the formula.

    private static double d1(double s, double k, double r, double t, double v) {
        double top = log(s / k) + (r + pow(v, 2) / 2) * t;
        double bottom = v * sqrt(t);
        return top / bottom;
    }

Now let’s move onto d2 which is significantly simpler.

d2 – A sub-formula of Black Scholes

The d2 formula is as below.

Its implementation using the same variable names is as below.

    private static double d2(double s, double k, double r, double t, double v) {
        return d1(s, k, r, t, v) - v * sqrt(t);
    }

Once you have prerequisite function implementations it’s so easy to compose higher level functions. Here d2 uses d1 from earlier on. Now let us return to the parent functions – the call and put formulas themselves.

Black Scholes formula

Now that we have prerequisite functions it should be simple to code up the top level formulas – the call and put price calculations.

The Java implementation is as below using the same variable naming as in the legend given above. There is an additional boolean variable which is set to true if the input is a call option and false otherwise.

    public static double calculate(boolean callOption, double s, double k, double r, double t,
            double v) {
        if (callOption) {
            double cd1 = cumulativeDistribution(d1(s, k, r, t, v));
            double cd2 = cumulativeDistribution(d2(s, k, r, t, v));
            return s * cd1 - k * exp(-r * t) * cd2;
        } else {
            double cd1 = cumulativeDistribution(-d1(s, k, r, t, v));
            double cd2 = cumulativeDistribution(-d2(s, k, r, t, v));
            return k * exp(-r * t) * cd2 - s * cd1;
        }
    }

Black Scholes in Java: The complete implementation

The complete Black Scholes Java implementation is given below to see at a glance.

package name.dhruba.black.scholes.formula;

import static java.lang.Math.PI;
import static java.lang.Math.abs;
import static java.lang.Math.exp;
import static java.lang.Math.log;
import static java.lang.Math.pow;
import static java.lang.Math.sqrt;

public enum BlackScholesFormula {

    _;

    private static final double P = 0.2316419;
    private static final double B1 = 0.319381530;
    private static final double B2 = -0.356563782;
    private static final double B3 = 1.781477937;
    private static final double B4 = -1.821255978;
    private static final double B5 = 1.330274429;

    public static double calculate(boolean callOption,
            double s, double k, double r, double t, double v) {
        if (callOption) {
            double cd1 = cumulativeDistribution(d1(s, k, r, t, v));
            double cd2 = cumulativeDistribution(d2(s, k, r, t, v));
            return s * cd1 - k * exp(-r * t) * cd2;
        } else {
            double cd1 = cumulativeDistribution(-d1(s, k, r, t, v));
            double cd2 = cumulativeDistribution(-d2(s, k, r, t, v));
            return k * exp(-r * t) * cd2 - s * cd1;
        }
    }

    private static double d1(double s, double k, double r, double t, double v) {
        double top = log(s / k) + (r + pow(v, 2) / 2) * t;
        double bottom = v * sqrt(t);
        return top / bottom;
    }

    private static double d2(double s, double k, double r, double t, double v) {
        return d1(s, k, r, t, v) - v * sqrt(t);
    }

    public static double cumulativeDistribution(double x) {
        double t = 1 / (1 + P * abs(x));
        double t1 = B1 * pow(t, 1);
        double t2 = B2 * pow(t, 2);
        double t3 = B3 * pow(t, 3);
        double t4 = B4 * pow(t, 4);
        double t5 = B5 * pow(t, 5);
        double b = t1 + t2 + t3 + t4 + t5;
        double cd = 1 - standardNormalDistribution(x) * b;
        return x < 0 ? 1 - cd : cd;
    }

    public static double standardNormalDistribution(double x) {
        double top = exp(-0.5 * pow(x, 2));
        double bottom = sqrt(2 * PI);
        return top / bottom;
    }

}

Compare this implementation to the alternative implementations linked to at the beginning of the article. Do you see the differences? Financial algorithms are sufficiently complex without programmers obfuscating their implementations even further. The function by function decomposition technique coupled with region based decomposition of individual functions makes such complex code maintainable and readable which should be our primary objectives when developing such algorithms. This is the guide I wished I had when I started looking into Black Scholes. Bear in mind I have omitted the javadoc on these methods for brevity which would normally contain online links to formulas etc.

Example outputs

A couple of examples follow of the Black Scholes calculation – one call and one put.

    public static void main(String[] args) {

        boolean call;
        double s, k, r, t, v, price;

        // call option example
        call = true;
        s = 56.25;
        k = 55;
        r = 0.0285;
        t = 0.34;
        v = 0.28;

        price = BlackScholesFormula.calculate(call, s, k, r, t, v);
        System.out.println(price); // 4.56

        // put option example
        call = false;
        s = 49;
        k = 50;
        r = 0.001;
        t = 0.25;
        v = 0.20;

        price = BlackScholesFormula.calculate(call, s, k, r, t, v);
        System.out.println(price); // 2.51

    }

Wolfram Alpha has an excellent online calculator that will allow you to check the result of the call and the put.

In my next and final article in the Black Scholes series I alter the implementation above to incorporate the Greeks (delta, gamma, vega, theta, rho) into it. Stay tuned.

Give me feedback!

Tech arms race in the Tron landscape

On the train, back to the real world, this evening for another year at work I came across a fascinating article in the New York Times titled ‘Electronic Trading Creates A New Trading Landscape – The New Speed Of Money Reshaping Markets‘. For the duration of that journey I was wholly engrossed in the article and the radial thought processes it triggered effortlessly and constantly on technology and finance. It was an inspiring read and one that made me glad and relieved that I happened to work in this industry.

Predominantly it talked about how, over time, smaller exchanges (such as Direct Edge) had reclaimed the overwhelming dominance and market share of the historic exchange duopoly of NASDAQ-NYSE and how, during that process, New Jersey had been transformed to become ‘the heart of Wall St’ through the placements of data centres within it that now host and operate some of the largest stock exchanges in the US. The charming reference to a ‘Tron landscape’ was made in the article based on the likeness of the blue phosphorescent lighting used in the datacentres for illumination to that in the film.

More interesting to me, however, was the story of how this progression had been driven from its core by the breakneck speed and sheer extent of technological automation, advancement and innovation leaving traders, regulators and the market struggling to keep up in its trail. So where are we now? Exchanges are distributed, leaner and more competitive. Through colocation, software advancement, closer proximity to targets and with new fibre optic pathways constantly being laid between critical geographic exchange data routes trading is faster. Through high frequency trading, dark pools and strategic algorithms – trading is more intelligent allowing arbitrage and price exploitation through micro trading under stealth.

What have been the consequences of such advancements over time however? The use of HFT to place a very large bulk order in small increments was found to be the root cause of a market crash last May when this particular HFT algorithm continued placing trades as part of a large order despite prices sinking part way through. As a result the SEC and the exchanges introduced a halt to trading on individual stocks if the price fell more than ten percent in a five minute period. Dark pools have been in the spotlight for being opaque and exempt from public scrutiny. And there is talk of regulation not only of data centres and colocation but of perhaps technology’s greatest achievement of all – speed. The unattended and perahps ill-considered advancement of technology for mostly selfish motives has resulted in a disproportionate loss of control, transparency and ethical considerations away from human discretion and towards machine code. Can technology continue to dominate this industry progression at its core to its advantage or will it become the very victim of its own success? I wonder where we go from here. What do you think?

Financial turmoil claims more casualties

The UK government nationalises Bradford & Bingley, Citi buys Wachovia for $2bn and the House of Representatives reject the $700bn bail-out plan as Republicans vote two-to-one against it. Just when you thought the short selling ban was stabilising the markets and the bail-out was reaching a positive consensus.

Update: The ban on predatory short selling proves counter-productive for the predator. And is Lloyds reconsidering its takeover of HBOS under falling share prices?

London tops world’s financial centres

FT reports that, out of 59 cities, London has yet again topped the list of the world’s financial centres but the gap between it and other rivals has been cut. The top seven world’s financial centres are as follows.  Note that as this bi-annual survey was taken in July it does not reflect the effects of the financial crises of the last month.

  1. London
  2. New York
  3. Singapore
  4. Hong Kong
  5. Zurich
  6. Geneva
  7. Tokyo

According to the study London lost points for the following.

The study authors suggest that London’s reputation is continuing to suffer from the government’s handling of the Northern Rock bank crisis and concerns that the regulatory environment is unpredictable and unstable.  London also slipped behind New York among government and regulatory respondents for the first time since the survey was taken.

Regarding which cities are likely to be the most significant in the future the following was said.

The survey also asks separate questions about which cities are the most likely to become significant in the future. Here Dubai, which came in 22nd on the main survey, was the big winner, with Singapore, Shanghai and several other Gulf state cities doing well.

It’s reassuring to know that I’m in the right place for now!

Update: FT reports US ‘will lose financial superpower status’.

Impact of financial crisis on Morgan Stanley

A brief chronological history follows of the impact that the financial crisis has had on Morgan Stanley in the last month or so.

In the face of its share price plunging Morgan Stanley (MS) starts talks (17/09/2008) with Wachovia and other interested parties about a possible merger. MS also talks (18/09/2008) to China Investment Corporation (CIC) (already owning a 9.9% stake) to sell a stake of up to 49%. MS management express that a stake sale to CIC is preferred to a merger with Wachovia.

Around the same time hedge funds reconsider doing business with MS and shift money out of MS’s prime brokerage as they reassess (18/09/2008) the risk of MS after Lehman’s collapse and as the cost of insuring MS’s bonds against default soars. This comes in spite of MS’s prime brokerage division being highly lucrative and the largest in the world.

These talks lose urgency after news of a government bail-out plan and are put on indefinite hold after both MS and GS are given surprise regulatory approval to turn themselves into bank holding companies. Mitsubishi UFG Group agrees to take a stake of upto 20% in MS in a $9bn deal further undermining the possibility of a merger between Wachovia and MS. Shares in MS jump 14%.

Today it is reported (26/09/2008) that last week MS lost close to a third of its assets in prime brokerage amounting to hundreds of billions of dollars as hedge funds fled. When Lehman collapsed and was put into administration $40bn of hedge fund assets were trapped and, recently, as hedge funds worried about fellow funds trapped in the Lehman collapse MS’s prime brokerage lost closer to half its assets. MS’s clients have said however that they are likely to return once markets stabilised.

To make matters worse rival banks such as JPMorgan, Credit Suisse, Citigroup, Deutsche Bank, Barclays Capital and UBS have since attracted many MS clients violating internal restrictions on doing so and despite MS executives’ efforts to persuade them not to do so when it became clear to them just how much potential custom was available.

In troubled times, GS and MS, the last two remainining large US investment banks, have been offered grace by the Federal Reserve in allowing them to becoming bank holding companies. GS has also received a cash injection of $5bn from a private investor Warren Buffett. However the paranoia, suspicion, speculation and fear prevailing in the market at the moment seem to make the market vortices indiscriminate and relentless and this has appeared to swiftly overwhelm good news in any one particular area.

In other news Washington Mututal has been seized and sold to JPMorgan Chase and talks relating to the $700bn US government bail-out fund have broken down. Reportedly the Bank of England, US Federal Reserve, the European Central Bank and the Swiss National Bank have intervened in the light of the breakdown and are now coordinating their efforts. Anyone feel the financial maelstrom widening its grip now? Is one mammoth all-encompassing solution for the entire crisis and its repercussions to date realistic or is it perhaps a little ambitious?

What next? I await every day with great curiosity.

Skillsmatter Java Finance Conferences

There are two skillsmatter conferences coming up relating to the use of Java in Finance.

Normally I’d be there without a doubt.  However normally these events are either in the evening or over a weekend.  This time they are both whole day weekday events.  Whether I’m there or not will depend on my employer.  I’d very much like to go though.  One can always learn.

Financial turmoil continues

Here’s a quick summary of what’s happened recently in rough order.

  • Barclays & Bank of America withdraw from Lehman buy.
  • US Government refuses to help Lehman.
  • Lehman files for bankruptcy protection.
  • Bank of America buys Merrill Lynch for $50bn valuing latter at $29/share (1.8x actual value).
  • US Government rescues AIG by offering an $85bn loan package for 80% public stake in firm.
  • Barclays buys Lehman’s core assets for $1.75bn and ponders taking on Lehman staff.
  • Lloyds TSB buys ailing HBOS for $12bn at 232p/share.
  • Morgan Stanley receives merger interest from Wachovia and others.