Julia Computing invites to the Julia in Finance Seminar in London on the 16th of March, organised in association with the CQF Institute. This event will introduce you to Julia, the easy-to-learn high-performance mathematical programming language that is taking the finance industry by storm.

The Julia in Finance Seminar takes place on Thursday, March 16th from 6:00 PM to 9 PM followed by refreshments and networking. The venue for this event is the Fitch Learning, The Corn Exchange, 55 Mark Lane, London, EC3R 7NE.

Come find out how quants, traders and data scientists from hedge funds, investment banks, and across financial services industry worldwide are using Julia to gain a mathematical computing advantage over their competitors by processing more data up to 1,000x faster than before. See how Julia enables innovation in the fintech and regtech sectors, helping companies and regulators keep ahead of a fast changing market.

There will be product demos, benchmarks, customer stories and use cases in Finance and Insurance, especially around trading, risk analytics and asset management among others.

Agenda

The event is free to attend in person, and will also be live-streamed worldwide. Please register below to reserve your seat.

About Julia

Julia is the simplest, fastest and most powerful numerical computing language available today. Julia combines the functionality of quantitative environments such as Python and R, with the speed of production programming languages like Java and C++ to solve big data and analytics problems. Julia delivers dramatic improvements in simplicity, speed, capacity, and productivity for data scientists, algorithmic traders, quants, scientists, and engineers who need to solve massive computational problems quickly and accurately.

Julia offers an unbeatable combination of simplicity and productivity with speed that is thousands of times faster than other mathematical, scientific and statistical computing languages.

Partners and users include: Intel, The Federal Reserve Bank of New York, Lincoln Laboratory (MIT), The Moore Foundation and a number of private sector finance and industry leaders, including several of the world’s leading hedge funds, investment banks, asset managers and insurers.

About Julia Computing, Inc.

Julia Computing, Inc. was founded in 2015 to develop products around Julia such as JuliaFin. These products help financial firms leverage the 1,000x improvement in speed and productivity that Julia provides for trading, risk analytics, asset management, macroeconomic modeling and other areas. Products of Julia Computing make Julia easy to develop, easy to deploy and easy to scale.

About CQF Institute

Part of Fitch Learning, the CQF Institute is the awarding body for the Certificate in Quantitative Finance and provides a platform for educating and building the quantitative finance community around the globe. Promoting the highest standard in practical financial engineering, the Institute offers its members exclusive access to educational content featured on the Institute website, keeping its members up to date on the latest quant finance industry practices.

Julia Computing invites you to the Julia in Finance Seminar in London on the 16th of March, organised in association with the CQF Institute. This event will…

By: Karl Pettersson

Re-posted from: http://static-dust.klpn.se/posts/2017-03-01-mcsite.html

A website with mortality charts built using Julia

Since 2015, I have run a website with cause-specific mortality trends. The idea is to have a static site, which gives fast and easy access to information about international mortality trends, using open data available from WHO (2016), which, for many countries, covers the time period from 1950 up until recent times. The website is inspired by Whitlock (2012), which contains comprehensible charts with mortality trends based on these data, but has been unmaintained since 2013, when its creator died. Other sites with international cause-specific mortality trends I have seen tend to be slower, due to dynamic chart generation, and to cover only shorter time periods.

My implementation of the site generator, which was written in Python and R, had become rather messy, and the chart tools I used (matplotlib and ggplot2) are not really suited to make interactive web charts. I decided to rewrite the routines to generate the charts and the site files in Julia (albeit with the help of some non-Julia tools, as described below). These routines are now available as a GitHub repo, and I use them to generate the site in both English and Swedish versions.

The site is built as follows with the Julia package (see the README in the repo for instructions). The whole process is controlled with a JSON configuration file. YAML, using some non-JSON features, might be less cumbersome, and will perhaps be used once there is full YAML write support implemented in Julia. Julia functions mentioned are in the main Mortchartgen.jl file, if not otherwise stated.

1. The WHO (2016) data files are downloaded and read into a MySQL database, using the functions in the Download.jl file.
2. These data files contain cause of death codes from many different versions of the ICD classifications for different time periods and countries, and the codes are also often at a much more detailed level than I use in the charts. Therefore, the data on deaths is grouped using regular expressions defined in the configuration file. To avoid repeating this time-consuming regular expression matching, the resulting DataFrames can be saved in CSV files. There are still some issues with unsupported datatypes in the MySQL.jl package, which mean that grouping cannot be done at the SQL level and that prepared SQL statements cannot be used.
3. The charts themselves are generated from the DataFrames created in step 2, using the Python Bokeh library, which is well-suited for interactive web visualizations. I call Bokeh directly using PyCall, instead of using the Bokeh.jl package, which is unmaintained. There is a batchplot function to generate all the charts for the site using the settings in the configuration file.
4. The writeplotsite function generates the charts as well as HTML tables with links to the charts, a documentation file in Markdown format, and navigation menus for a given language, and copies these to a given output location. To generate the site files, except for the charts themselves, templates processed with Mustache.jl are used.
5. The final generation of the site is done using Hakyll, a static site generator written in Haskell. In the output directory generated in step 4, there will be a Haskell source file, site.hs, which, provided that a Haskell complier and the Hakyll libraries are installed, can be compiled to an executable file. This file can then be run as ./site build to generate the site, which can then be uploaded to a web server. The resulting site is static in the sense that it has no code running on the server-side (but rendering the charts requires JavaScript on the client side).

References