demos/LLVM-Cauldron.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# LLVM Cauldron - Wuthering Bytes 2016-09-08\n",
    "\n",
    "# Generating Python & Ruby bindings from C++\n",
    "\n",
    "### Jonathan B Coe\n",
    "### jonathanbcoe@gmail.com\n",
    "\n",
    "## https://github.com/ffig/ffig\n",
    "\n",
    "[Updated Links and API use on 2018-01-25]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Write a C++ class out to a file in the current working directory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "outputfile = \"Shape.h\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting Shape.h\n"
     ]
    }
   ],
   "source": [
    "%%file $outputfile\n",
    "#include <stdexcept>\n",
    "#include <string>\n",
    "\n",
    "#ifdef __clang__\n",
    "  #define C_API __attribute__((annotate(\"GENERATE_C_API\")))\n",
    "#else\n",
    "  #define C_API\n",
    "#endif\n",
    "\n",
    "#include <ffig/attributes.h>\n",
    "\n",
    "struct FFIG_EXPORT Shape\n",
    "{\n",
    "  virtual ~Shape() = default;\n",
    "  virtual double area() const = 0;\n",
    "  virtual double perimeter() const = 0;\n",
    "  virtual const char* name() const = 0;\n",
    "} __attribute__((annotate(\"GENERATE_C_API\")));\n",
    "\n",
    "static const double pi = 4.0;\n",
    "\n",
    "class Circle : public Shape\n",
    "{\n",
    "  const double radius_;\n",
    "\n",
    "public:\n",
    "  double area() const override\n",
    "  {\n",
    "    return pi * radius_ * radius_;\n",
    "  }\n",
    "\n",
    "  double perimeter() const override\n",
    "  {\n",
    "    return 2 * pi * radius_;\n",
    "  }\n",
    "\n",
    "  const char* name() const override\n",
    "  {\n",
    "    return \"Circle\";\n",
    "  }\n",
    "\n",
    "  Circle(double radius) : radius_(radius)\n",
    "  {\n",
    "    if ( radius < 0 ) \n",
    "    { \n",
    "      std::string s = \"Circle radius \\\"\" + std::to_string(radius_) + \"\\\" must be non-negative.\";\n",
    "      throw std::runtime_error(s);\n",
    "    }\n",
    "  }\n",
    "};"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Compile our header to check it's valid C++"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%sh\n",
    "clang++-3.8 -x c++ -fsyntax-only -std=c++14 -I../ffig/include Shape.h "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Read the code using libclang"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "import sys\n",
    "sys.path.insert(0,'..')\n",
    "\n",
    "import ffig.clang.cindex\n",
    "\n",
    "index = ffig.clang.cindex.Index.create()\n",
    "translation_unit = index.parse(outputfile, ['-x', 'c++', '-std=c++14', '-I../ffig/include'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Shape.h (TRANSLATION_UNIT)\n",
      "  +--Shape (STRUCT_DECL)\n",
      "  |  +--FFIG:EXPORT (ANNOTATE_ATTR)\n",
      "  |  +--GENERATE_C_API (ANNOTATE_ATTR)\n",
      "  |  +--~Shape (DESTRUCTOR)\n",
      "  |  |  +-- (COMPOUND_STMT)\n",
      "  |  +--area (CXX_METHOD)\n",
      "  |  +--perimeter (CXX_METHOD)\n",
      "  |  +--name (CXX_METHOD)\n",
      "  +--pi (VAR_DECL)\n",
      "  |  +-- (FLOATING_LITERAL)\n",
      "  +--Circle (CLASS_DECL)\n",
      "     +--struct Shape (CXX_BASE_SPECIFIER)\n",
      "     |  +--struct Shape (TYPE_REF)\n",
      "     +--radius_ (FIELD_DECL)\n",
      "     +-- (CXX_ACCESS_SPEC_DECL)\n",
      "     +--area (CXX_METHOD)\n",
      "     |  +-- (CXX_OVERRIDE_ATTR)\n",
      "     |  +-- (COMPOUND_STMT)\n",
      "     |     +-- (RETURN_STMT)\n",
      "     |        +-- (BINARY_OPERATOR)\n",
      "     |           +-- (BINARY_OPERATOR)\n",
      "     |           |  +--pi (UNEXPOSED_EXPR)\n",
      "     |           |  |  +--pi (DECL_REF_EXPR)\n",
      "     |           |  +--radius_ (UNEXPOSED_EXPR)\n",
      "     |           |     +--radius_ (MEMBER_REF_EXPR)\n",
      "     |           +--radius_ (UNEXPOSED_EXPR)\n",
      "     |              +--radius_ (MEMBER_REF_EXPR)\n",
      "     +--perimeter (CXX_METHOD)\n",
      "     |  +-- (CXX_OVERRIDE_ATTR)\n",
      "     |  +-- (COMPOUND_STMT)\n",
      "     |     +-- (RETURN_STMT)\n",
      "     |        +-- (BINARY_OPERATOR)\n",
      "     |           +-- (BINARY_OPERATOR)\n",
      "     |           |  +-- (UNEXPOSED_EXPR)\n",
      "     |           |  |  +-- (INTEGER_LITERAL)\n",
      "     |           |  +--pi (UNEXPOSED_EXPR)\n",
      "     |           |     +--pi (DECL_REF_EXPR)\n",
      "     |           +--radius_ (UNEXPOSED_EXPR)\n",
      "     |              +--radius_ (MEMBER_REF_EXPR)\n",
      "     +--name (CXX_METHOD)\n",
      "     |  +-- (CXX_OVERRIDE_ATTR)\n",
      "     |  +-- (COMPOUND_STMT)\n",
      "     |     +-- (RETURN_STMT)\n",
      "     |        +-- (UNEXPOSED_EXPR)\n",
      "     |           +--\"Circle\" (STRING_LITERAL)\n",
      "     +--Circle (CONSTRUCTOR)\n",
      "        +--radius (PARM_DECL)\n",
      "        +--radius_ (MEMBER_REF)\n",
      "        +--radius (UNEXPOSED_EXPR)\n",
      "        |  +--radius (DECL_REF_EXPR)\n",
      "        +-- (COMPOUND_STMT)\n",
      "           +-- (IF_STMT)\n",
      "              +-- (BINARY_OPERATOR)\n",
      "              |  +--radius (UNEXPOSED_EXPR)\n",
      "              |  |  +--radius (DECL_REF_EXPR)\n",
      "              |  +-- (UNEXPOSED_EXPR)\n",
      "              |     +-- (INTEGER_LITERAL)\n",
      "              +-- (COMPOUND_STMT)\n",
      "                 +-- (DECL_STMT)\n",
      "                 |  +--s (VAR_DECL)\n",
      "                 |     +--std (NAMESPACE_REF)\n",
      "                 |     +--string (TYPE_REF)\n",
      "                 |     +-- (UNEXPOSED_EXPR)\n",
      "                 |        +-- (CALL_EXPR)\n",
      "                 |           +-- (UNEXPOSED_EXPR)\n",
      "                 |              +-- (UNEXPOSED_EXPR)\n",
      "                 |                 +--operator+ (CALL_EXPR)\n",
      "                 |                    +-- (UNEXPOSED_EXPR)\n",
      "                 |                    |  +-- (UNEXPOSED_EXPR)\n",
      "                 |                    |     +--operator+ (CALL_EXPR)\n",
      "                 |                    |        +-- (UNEXPOSED_EXPR)\n",
      "                 |                    |        |  +--\"Circle radius \\\"\" (STRING_LITERAL)\n",
      "                 |                    |        +--operator+ (UNEXPOSED_EXPR)\n",
      "                 |                    |        |  +--operator+ (DECL_REF_EXPR)\n",
      "                 |                    |        +-- (UNEXPOSED_EXPR)\n",
      "                 |                    |           +-- (UNEXPOSED_EXPR)\n",
      "                 |                    |              +--to_string (CALL_EXPR)\n",
      "                 |                    |                 +--to_string (UNEXPOSED_EXPR)\n",
      "                 |                    |                 |  +--to_string (DECL_REF_EXPR)\n",
      "                 |                    |                 |     +--std (NAMESPACE_REF)\n",
      "                 |                    |                 +--radius_ (UNEXPOSED_EXPR)\n",
      "                 |                    |                    +--radius_ (MEMBER_REF_EXPR)\n",
      "                 |                    +--operator+ (UNEXPOSED_EXPR)\n",
      "                 |                    |  +--operator+ (DECL_REF_EXPR)\n",
      "                 |                    +-- (UNEXPOSED_EXPR)\n",
      "                 |                       +--\"\\\" must be non-negative.\" (STRING_LITERAL)\n",
      "                 +-- (UNEXPOSED_EXPR)\n",
      "                    +-- (CXX_THROW_EXPR)\n",
      "                       +-- (CALL_EXPR)\n",
      "                          +-- (UNEXPOSED_EXPR)\n",
      "                             +-- (UNEXPOSED_EXPR)\n",
      "                                +-- (CXX_FUNCTIONAL_CAST_EXPR)\n",
      "                                   +--std (NAMESPACE_REF)\n",
      "                                   +--class std::runtime_error (TYPE_REF)\n",
      "                                   +-- (UNEXPOSED_EXPR)\n",
      "                                      +--runtime_error (CALL_EXPR)\n",
      "                                         +--s (UNEXPOSED_EXPR)\n",
      "                                            +--s (DECL_REF_EXPR)\n"
     ]
    }
   ],
   "source": [
    "import asciitree\n",
    "\n",
    "def node_children(node):\n",
    "    return (c for c in node.get_children() if c.location.file.name == outputfile)\n",
    "\n",
    "print asciitree.draw_tree(translation_unit.cursor,\n",
    "  lambda n: [c for c in node_children(n)],\n",
    "  lambda n: \"%s (%s)\" % (n.spelling or n.displayname, str(n.kind).split(\".\")[1]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Turn the AST into some easy to manipulate Python classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "from ffig import cppmodel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "model = cppmodel.Model(translation_unit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<cppmodel.Model filename=Shape.h, classes=['_opaque_pthread_attr_t', '_opaque_pthread_cond_t', '_opaque_pthread_condattr_t', '_opaque_pthread_mutex_t', '_opaque_pthread_mutexattr_t', '_opaque_pthread_once_t', '_opaque_pthread_rwlock_t', '_opaque_pthread_rwlockattr_t', '_opaque_pthread_t', 'sigevent', 'sigaction', 'sigvec', 'sigstack', 'timeval', 'rusage', 'rusage_info_v0', 'rusage_info_v1', 'rusage_info_v2', 'rusage_info_v3', 'rusage_info_v4', 'rlimit', 'proc_rlimit_control_wakeupmon', 'is_scalar', 'is_destructible', 'exception', 'bad_exception', 'exception_ptr', 'exception_ptr', 'nested_exception', 'timespec', 'tm', 'ios_base', 'logic_error', 'runtime_error', 'domain_error', 'invalid_argument', 'length_error', 'out_of_range', 'range_error', 'overflow_error', 'underflow_error', 'piecewise_construct_t', 'type_info', 'bad_cast', 'bad_typeid', 'nothrow_t', 'bad_alloc', 'bad_array_new_length', 'bad_array_length', 'less', 'allocator_arg_t', 'input_iterator_tag', 'output_iterator_tag', 'forward_iterator_tag', 'bidirectional_iterator_tag', 'random_access_iterator_tag', 'tuple', 'atomic_flag', 'allocator', 'allocator', 'auto_ptr', '_PairT', 'bad_weak_ptr', 'pointer_safety', 'char_traits', 'char_traits', 'char_traits', 'char_traits', 'basic_string', 'basic_string', 'Shape', 'Circle'], functions=['_OSSwapInt16', '_OSSwapInt32', '_OSSwapInt64', 'set_unexpected', 'get_unexpected', 'unexpected', 'set_terminate', 'get_terminate', 'terminate', 'uncaught_exception', 'uncaught_exceptions', 'current_exception', 'rethrow_exception', 'isascii', 'isalnum', 'isalpha', 'isblank', 'iscntrl', 'isdigit', 'isgraph', 'islower', 'isprint', 'ispunct', 'isspace', 'isupper', 'isxdigit', 'toascii', 'tolower', 'toupper', 'digittoint', 'ishexnumber', 'isideogram', 'isnumber', 'isphonogram', 'isrune', 'isspecial', 'iswalnum', 'iswalpha', 'iswcntrl', 'iswctype', 'iswdigit', 'iswgraph', 'iswlower', 'iswprint', 'iswpunct', 'iswspace', 'iswupper', 'iswxdigit', 'towlower', 'towupper', 'set_new_handler', 'get_new_handler', 'operator new', 'operator new', 'operator delete', 'operator delete', 'operator delete', 'operator new[]', 'operator new[]', 'operator delete[]', 'operator delete[]', 'operator delete[]', 'operator new', 'operator new[]', 'operator delete', 'operator delete[]', 'tuple_cat', 'atomic_flag_test_and_set', 'atomic_flag_test_and_set', 'atomic_flag_test_and_set_explicit', 'atomic_flag_test_and_set_explicit', 'atomic_flag_clear', 'atomic_flag_clear', 'atomic_flag_clear_explicit', 'atomic_flag_clear_explicit', 'atomic_thread_fence', 'atomic_signal_fence', 'get_pointer_safety', 'declare_reachable', 'declare_no_pointers', 'undeclare_no_pointers', 'align', 'operator\"\"sv', 'operator\"\"sv', 'operator\"\"sv', 'operator\"\"sv', 'iswblank', 'iswascii', 'iswhexnumber', 'iswideogram', 'iswnumber', 'iswphonogram', 'iswrune', 'iswspecial', 'stoi', 'stol', 'stoul', 'stoll', 'stoull', 'stof', 'stod', 'stold', 'to_string', 'to_string', 'to_string', 'to_string', 'to_string', 'to_string', 'to_string', 'to_string', 'to_string', 'stoi', 'stol', 'stoul', 'stoll', 'stoull', 'stof', 'stod', 'stold', 'to_wstring', 'to_wstring', 'to_wstring', 'to_wstring', 'to_wstring', 'to_wstring', 'to_wstring', 'to_wstring', 'to_wstring', 'operator\"\"s', 'operator\"\"s', 'operator\"\"s', 'operator\"\"s']>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['to_wstring', 'operator\"\"s', 'operator\"\"s', 'operator\"\"s', 'operator\"\"s']"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[f.name for f in model.functions][-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['char_traits', 'basic_string', 'basic_string', 'Shape', 'Circle']"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[c.name for c in model.classes][-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "shape_class = [c for c in model.classes if c.name=='Shape'][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Shape::area', 'Shape::perimeter', 'Shape::name']"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[\"{}::{}\".format(shape_class.name,m.name) for m in shape_class.methods]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Look at the templates the generator uses"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{% for class in classes %}\r\n",
      "{\r\n",
      "  \"name\" : \"{{class.name}}\"{% if class.methods %},\r\n",
      "  \"methods\" : [{% for method in class.methods %}\r\n",
      "    {\r\n",
      "      \"name\" : \"{{method.name}}\",\r\n",
      "      \"return_type\" : \"{{method.return_type}}\"\r\n",
      "    }{% if not loop.last %},{% endif %}{% endfor %}\r\n",
      "  ]{% endif %}\r\n",
      "}{% if not loop.last %},{% endif %}{% endfor %}\r\n",
      "]\r\n"
     ]
    }
   ],
   "source": [
    "%cat ../ffig/templates/json.tmpl"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Run the code generator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true,
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [],
   "source": [
    "%%sh\n",
    "cd ..\n",
    "python -m ffig -b json.tmpl rb.tmpl python -m Shape -i demos/Shape.h -o demos/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "source": [
    "See what it created"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CMakeCache.txt            Makefile                  Shape_c.cpp\r\n",
      "\u001b[34mCMakeFiles\u001b[m\u001b[m/               PyDataLondon-2017.ipynb   Shape_c.h\r\n",
      "CMakeLists.txt            Shape.h                   cmake_install.cmake\r\n",
      "CppLondon_Aug-2017.ipynb  Shape.json                \u001b[31mlibShape_c.dylib\u001b[m\u001b[m*\r\n",
      "LLVM-Cauldron.ipynb       Shape.rb                  \u001b[34mshape\u001b[m\u001b[m/\r\n"
     ]
    }
   ],
   "source": [
    "%ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[{\r\n",
      "  \"name\" : \"Shape\",\r\n",
      "  \"methods\" : [    {\r\n",
      "      \"name\" : \"area\",\r\n",
      "      \"return_type\" : \"double\"\r\n",
      "    },    {\r\n",
      "      \"name\" : \"perimeter\",\r\n",
      "      \"return_type\" : \"double\"\r\n",
      "    },    {\r\n",
      "      \"name\" : \"name\",\r\n",
      "      \"return_type\" : \"const char *\"\r\n",
      "    }  ]}]"
     ]
    }
   ],
   "source": [
    "%cat Shape.json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "Build some bindings with the generated code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Overwriting CMakeLists.txt\n"
     ]
    }
   ],
   "source": [
    "%%file CMakeLists.txt\n",
    "\n",
    "cmake_minimum_required(VERSION 3.0)\n",
    "set(CMAKE_CXX_STANDARD 14)\n",
    "add_library(Shape_c SHARED Shape_c.cpp)\n",
    "target_include_directories(Shape_c PRIVATE ../ffig/include)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "slideshow": {
     "slide_type": "fragment"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-- Configuring done\n",
      "-- Generating done\n",
      "-- Build files have been written to: /Users/jon/DEV/FFIG/demos\n",
      "Scanning dependencies of target Shape_c\n",
      "[ 50%] Building CXX object CMakeFiles/Shape_c.dir/Shape_c.cpp.o\n",
      "[100%] Linking CXX shared library libShape_c.dylib\n",
      "[100%] Built target Shape_c\n"
     ]
    }
   ],
   "source": [
    "%%sh\n",
    "cmake . \n",
    "cmake --build ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Circle with radius 8 has area 256.0\n"
     ]
    }
   ],
   "source": [
    "%%python2\n",
    "import shape\n",
    "c = shape.Circle(8)\n",
    "\n",
    "print \"A {} with radius {} has area {}\".format(c.name(), 8, c.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Circle with radius 8 has area 256.0\n"
     ]
    }
   ],
   "source": [
    "%%script pypy\n",
    "import shape\n",
    "c = shape.Circle(8)\n",
    "\n",
    "print \"A {} with radius {} has area {}\".format(c.name(), 8, c.area())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A Circle with radius 8 has area 256.0\n"
     ]
    }
   ],
   "source": [
    "%%ruby\n",
    "load \"Shape.rb\"\n",
    "c = Circle.new(8)\n",
    "\n",
    "puts(\"A #{c.name()} with radius #{8} has area #{c.area()}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}