Category Archives: Conferences

Avoiding “Excel Hell!” using a Python-based Toolchain

Update (Feb 6, 2014):  Enthought is now the exclusive distributor of PyXLL, a solution that helps users avoid “Excel Hell” by making it easy to develop add-ins for Excel in Python. Learn more here.

Didrik Pinte gave an informative, provocatively-titled presentation at the second, in-person New York Quantitative Python User’s Group (NY QPUG) meeting earlier this month.

There are a lot of examples in the press of Excel workflow mess-ups and spreadsheet errors contributing to some eye-popping mishaps in the finance world (e.g. JP Morgan’s spreadsheet issues may have led to the 2012 massive loss at “the London Whale”). Most of these can be traced to similar fundamental issues:

  • Data referencing/traceability

  • Numerical errors

  • Error-prone manual operations (cut & paste, …)

  • Tracing IO’s in libraries/API’s

  • Missing version control

  • Toolchain that doesn’t meet the needs of researchers, analysts, IT, etc.

Python, the coding language and its tool ecosystem, can provide a nice solution to these challenges, and many organizations are already turning to Python-based workflows in response. And with integration tools like PyXLL (to execute Python functions within Excel) and others, organizations can adopt Python-based workflows incrementally and start improving their current “Excel Hell” situation quickly.

For the details check out the video of Didrik’s NY QPUG presentation.  He demonstrates a an example solution using PyXLL and Enthought Canopy.

[vimeo 67327735]

And grab the PDF of his slides here.


It would be great to hear your stories about “Excel Hell”. Let us know below.

–Brett Murphy


Well, DataGotham is over. The conference featured a wide cross section of the data community in NYC. Talks spanned topics from “urban science” to “finding racism on FourSquare” to “creating an API for spaces.” Don’t worry, the videos will be online soon so you can investigate yourself. The organizers did a great job putting a conference of this size together on relatively short notice. Bravo NYC data crunchers!

One thing I somehow missed was a network graph created by the organizers to illustrate the tools used by attendees. I am happy to see python leading the way! The thickness of the edge indicates the number of people using both tools. It seems there are a lot of people trying to make Python and R “two great tastes that go great together.” I’m curious as to why more Python users aren’t using numpy and scipy. Food for thought…

Got tools?

SIGGRAPH 2012: Mobile, OpenGL 4.3 and Python

I recently had the opportunity to attend SIGGRAPH in LA. For those of you who don’t know, SIGGRAPH is an annual conference for Graphics and Visualization that does a great job of attracting people from both the scientific and artistic halves of the visualization community. For broader coverage, you can read some of the usual blog coverage here. I was particularly interested, however, in the OpenGL developments.

Increased focus on performance/watt for mobile applications

SIGGRAPH 2012 was important for many reasons, but particularly for those of us that use OpenGL (this year was the 20th anniversary of the OpenGL API). OpenGL 4.3 and OpenGL ES 3.0 were announced and there were many interesting sessions on the new OpenGL release (more about this later) and graphics on mobile devices.

The rapid ascent of mobile and its dominance as the primary computer that people interact with on a daily basis has opened up an interesting challenge for people designing games and visualization — the difference in the power envelope between mobile devices and their desktop brethren. The power envelope of high-end desktop devices is ~300 watt while the power envelope of mobile gpu’s is < 1 watt. This power disparity implies a massive gulf in performance across the full spectrum of devices, assuming similar architectures are in use.

Multiple speakers stressed that power consumption should be a first class design metric when designing graphics algorithms along with the traditional metric of performance. Currently, the tools for profiling and measuring power consumption of algorithms are almost non-existent and nowhere near the sophistication of tools for measuring performance. Nevertheless, data transfers over a bus were recognized as an expensive power activity and a place where power savings can be realized.

To this end, OpenGL (finally) announced new texture compression formats that are royalty free, work on both OpenGL and OpenGL ES and are guaranteed on all compliant OpenGL implementations. This is great for developers since we can finally assume that this functionality will be available across all devices. More information about the new texture compression formats lives here.

Using OpenGL 4.3 from Python: Rabbit of Caerbannog

The OpenGL ARB committee started an effort to modernise OpenGL around OpenGL 3.x and large parts of the old fixed pipeline functionality was deprecated. These changes were great from a driver implementors point of view and should allow developers to write code that runs faster on modern GPU’s. However the deprecations have obsoleted much of the OpenGL tutorials that exist on the internet. I have listed two examples here which do not use deprecated functionality and can be used as a starting point to write modern OpenGL graphics examples in Python.

So, how do you use the brand spanking new 4.3 api’s from Python? I’ve written a code sample that uses modern opengl (no deprecated functionality used) to draw a triangle from Python.

Opengl display output showing a colored triangle

Triangle drawn using modern opengl and Python

For the code please refer to

For fun, here’s a screenshot of Stanford bunny drawn using modern OpenGL –

Stanford bunny drawn using modern OpenGL and python

Stanford bunny drawn using modern OpenGL and python

For the code please refer to


  1. Right now only Nvidia has Opengl 4.3 drivers available
  2. OSX only supports Opengl versions upto 3.2 as of today
  3. You will require a trunk release of PyOpenGL to create a OpenGL 4.3 context
  4. Code for the examples can be obtained from
  5. I have conservatively marked the OpenGL version as 3.2 here since many readers will not have 4.3 working on their machines. To enable OpenGL 4.3 change the OpenWindowHint call for OPENGL_VERSION_MAJOR to 4 and the OpenWindowHint call for OPENGL_VERSION_MINOR to 3.

EuroScipy 2012

EuroScipy 2012 starts tomorrow! Four days of exciting tutorials and talks. The conference is hosted in Brussels at ULB (which you probably know if you went to FOSDEM).

The first two days are dedicated to a great set of tutorials. The introductory track should please any new data analyst starting with Python:

  • array manipulation with NumPy
  • plotting with Matplotlib
  • introduction to scientific computing with Scipy.

In the advanced track, HPC and parallel computing are the main focus but tutorials also offer:

  • advanced numpy and scipy
  • time series data analysis with Pandas
  • visualisation
  • packaging and scientific software development insights.


Last but not least, the European Enthought team will offer:

  • a tutorial on Enaml, a new library that makes GUI programming fun
  • a tutorial on how to write robust scientific code with testing
  • a tutorial about Bento, a pythonic packaging system for Python software

Plan for an exciting weekend as well with various talks covering finance to geophysics to biology. Don’t forget to come for the keynote sessions with David Beazley on Saturday and Eric Jones, Enthought’s CEO, on Sunday!


See you in Brussels!

TGIF: SciPy 2012 Recap Video

As we wait for the SciPy talk videos to make their way onto the web, we’d like to share a short film recapping SciPy 2012.

The latest iteration of the SciPy conference was another great example of the scientific python community coming together to share “the latest and greatest.” Most organizations want to change the world in some way or another. At Enthought, we attempt to do this by building tools that help our customers – in both academia and industry – concentrate on solving their actual problems rather than wrestling with technology. We believe Python’s ability to operate smoothly in different contexts (e.g., desktop, web, array-based and distributed computing, etc.) makes it a highly productive and pragmatic tool with which to build solutions.

The SciPy community is changing the world by continually pushing technical computing forward in a pragmatic way. One just has to look at the content and tools presented at SciPy historically to know that this community has been been up to its neck in “data science” for some time. One could also argue, however, that SciPy is one of the best kept secrets in technical computing. As the recent focus on MapReduce solutions illustrates, the world is in the grips of “big computation.” It will only get tougher in the foreseeable future. At the same time, “big data” is a relative term. “Big” for a bioinformatician is different than for a macro hedge fund analyst, and these differences can often be measured in orders of magnitude. And when it comes to solutions, rarely does one size fit all.

In contrast, SciPy addresses a broad array of problems. SciPy 2012 offered High Performance Computing and Visualization tracks, with tutorials on machine learning, plotting, parallel computing, and time series analysis. Sometimes all these topics could be found in a single talk (see VisIt). The community also demonstrated some open-mindedness by inviting Jeff Bezanson, one of the authors of Julia, to share his experience building a language specifically designed for technical computing. It turns out there is a fair amount of overlap between what the SciPy community and the Julia team are planning. With LLVM IR increasingly being viewed as a common target, there is real excitement about what the future holds for language development and interaction.

This is all to say that SciPy has a lot to offer the world. Stay tuned for a bigger and better SciPy next year!

Mayavi – Talk at Fifth Elephant

The lead developer and creator of the 3D visualization package Mayavi, Dr. Prabhu Ramachandran, will provide a brief overview of Mayavi followed by his experience throughout the development of the package at the Fifth Elephant conference to be held in Bangalore, India.

Here is a brief video preview of the Mayavi user interface and Prabhu’s talk at Fifth Elephant.

Scipy 2012

No Mas

Scipy 2012 is wrapping up today tomorrow as bands of sprinters come together to hack away on their projects of interest. Many thanks to the sponsors and volunteers that made this year’s Scipy another success. The Scipy conference has always been highly technical. Although “data science” and “big data” have become buzzwords recently, Scipy has been exploring these themes for many years. Projects featuring machine learning, high performance computing, and visualization were in full attendance at this year’s Scipy. Stay tuned for links to talk videos (care of Next Day Video)!

Chaco Pygotham Talk

The penultimate video in our series of talks is an overview of Chaco, Enthought’s interactive plotting toolkit. Sit back and enjoy! You can find the github page here.