Text of python.org › about › success › resolver as Styx crawled it on Nov 19, 2026. The page may have changed since. Only its words are kept, without pictures or layout, and only the first part of a long page.

Open the live page

Python Success Stories | Python.org

Notice: This page displays a fallback because interactive scripts did not run. Possible causes include disabled JavaScript or failure to load scripts or stylesheets. Introducing IronPython Pairing the Python language's expressivity with the seamless availability of the extensive .NET class libraries makes IronPython a powerful combination for Resolver Systems. About Resolver Systems Resolver Systems is a two year-old start-up based on the outskirts of London's financial district.

Our first product, Resolver One, is a desktop and web-accessible spreadsheet aimed primarily at the financial services market. It is written entirely in IronPython, and directly exposes end-users to Python, both as expressions in cell formulae, and as an embedded scripting language which provides programmatic access to spreadsheet content. Resolver One launched in Spring of 2008, by which time the team had grown to fourteen people, and the codebase to 40k lines of product and 140k lines of tests.

Why IronPython? From the outset, it was clear that it would be good to use an existing language as our embedded scripting language, rather than inventing one. A dynamic language would confer appropriate type semantics on the spreadsheet formulae. It would be advantageous if this same language could also be used for development of the Resolver One application itself. There was also a requirement for .NET interoperability, so that both our own development team and our users could invoke existing .NET libraries, especially the powerful Graphical User Interface (GUI) components in the System.Windows.Forms module of the .NET class libraries themselves.

Python was regarded fondly by our founders, but could not directly fulfil the requirement for .NET interoperability. Python for .NET was considered, allowing Python developers to call .NET assemblies, but in the end this lost out to IronPython, a reimplementation of Python as a .NET language, which runs directly on the Common Language Runtime (CLR). At the time, IronPython felt like a somewhat risky proposition. At v0.7 it was still relatively young, and had an extremely low profile.

The acquisition of IronPython by Microsoft also raised uncertainties about the project's future, should it be deemed contrary to Microsoft's strategy. However, our initial experiments with IronPython went well. It turned out to be trivially easy to create a GUI using the excellent design tool in Visual Studio, then inherit from these classes in Python code and implement all behaviour in Python, in the Integrated Development Environment (IDE) of one's choice. (Developers choose their own IDE, so we sport an entertaining diversity of them, currently: Eclipse, Vi, Emacs, Wing, Komodo and the lightweight but surprisingly useful Textpad.) For example, IronPython code can easily display a .NET Form, using: # Add a reference to the required .NET assembly # This only need be done once per application import clr clr.AddReference("System.Windows.Forms") # Then import symbols from the assembly, as if from a Python module from System.Windows.Forms import Application, Form # Then use the imported symbols as though they were native Python types form = Form() form.Text = "Hello World" Application.Run(form) Which displays this fully-functional Windows application: Figure 1.

"Hello World" GUI application created from IronPython. Zoom in Over time, other strengths of IronPython have become apparent. Using the .NET threading model means that applications are able to overcome CPython's global interpreter lock. Resolver One uses this to run background recalculation threads on different cores, to remain responsive during lengthy calculations. Meanwhile, the concerns about the IronPython project have diminished.

The viability and visibility of IronPython has gone from strength to strength. Today, with dynamic languages getting ever more attention, IronPython forms the flagship language for Microsoft's recent Dynamic Language Runtime (DLR), upon which future versions of Visual Basic will be based, and a healthy future seems assured. The success of IronPython is well deserved. It has proven to be a very capable implementation, with transparent mappings between Python and .NET types, and very few differences between it and CPython to catch out unwary developers.

Pairing up the expressivity and power of the Python language with the highly functional and extensive .NET class libraries is a powerful combination. Mixing Generated and User-Written Code Resolver One pre-processes users' cell expressions to convert common spreadsheet idioms into legal Python statements. These statements are executed to determine the values displayed in the GUI's grid. The order in which the statements are executed depends upon the dependencies between them.

For example, if cell A1 references the value of B1, then B1 must be evaluated first. This provides us with the basic spreadsheet model that has proven so valuable for ad-hoc investigation of numerical models. Figure 2. The basic steps Resolver One uses to evaluate cell formulae. Zoom in However, using this method, it is difficult for users to create spreadsheets of any complexity without using cell expressions that are enormous and unwieldy, mixing data, business logic and presentation information.

These expressions get duplicated (and almost-duplicated) many times. Any model which is more than trivial quickly degenerates into an unmaintainable 'Frankensheet'. To combat this, Resolver One allow users to intersperse the evaluation of cell formulae with arbitrary code of their own. This is done by displaying the code that is generated from cell expressions in a pane of the GUI. The user is free to insert any Python of their own devising, to be executed before, during or after the evaluation of the spreadsheet cell values.

Figure 3. The code pane within the Resolver One application. Zoom in So the spreadsheet, with all its data, expressions and user-customised functions and algorithms, becomes a single, executable Python script. The GUI and the code are two interchangeable views of the same underlying mathematical model - editing one automatically updates the other. This retains the accessibility and experimental immediacy of a traditional spreadsheet user interface, while allowing the user to tame the spreadsheet's complexity using the same techniques that software engineers have been inventing for the last few decades: elimination of redundancies; functional decomposition; object orientation; external libraries; and other high-level abstractions - all in a modern, fully-featured programming language.

An important feature of Python that we were rely on heavily for this, and which we were happy to see supported in IronPython, was the execution of cell formulae and user code in a separate instance of the underlying Python engine. This isolates the user's spreadsheet code from the running instance of the Resolver One application, preventing us from polluting each other's namespace, or from having to share global settings such as the Python recursion limit.

Supporting Agile Development Python is a modern, expressive language, which supports many aspects of a modern, agile software development process. Small Code Base Python's high level of abstraction and expressivity allows our developers to produce complex functionality using a minimal amount of code. This has enabled a small team of engineers - linearly growing from two to fourteen employees over two years - to create a fully-featured solution with a manageable codebase.

Unit and Acceptance Testing Python's built-in 'unittest' module provides everything needed to get started with most unit testing, and has proven extendible enough for us to gradually build our own acceptance test framework on top of it. This uses the .NET API to directly stimulate mouse and keyboard input events to manipulate the application's GUI, and then asserting the existence and content of various GUI components like windows and textb

The rest of this page is on the live site.