Your SlideShare is downloading. ×
0
Introduction to GIL,Boost and GenericProgrammingHailin JinAdvanced Technology LabsAdobe Systems Incorporatedhttp://www.ado...
Outline     GIL     Boost     Generic programming     STL     Summary2010 Adobe Systems Incorporated. All Rights Rese...
What is GIL?     Generic Image Library     C++ image library     Open-source     http://opensource.adobe.com/gil     ...
GIL overview     Image containers     1-D iterators for traversing rows and columns     2-D iterators (locator) for arb...
People     Lubomir Bourdev                                    Hailin Jin   Christian Henning         Adobe                ...
GIL history     Started as an Adobe internal project in 2005     Version 1.0 in June 2006     Accepted into Boost in No...
License     Initially: MIT license     Currently: Boost Software License (similar to the MIT license)     Free to use, ...
Image processing libraries     Your own image libraries     OpenCV     CImg     Vigra     GIL works third-party algor...
     http://www.boost.org     High-quality C++ libraries     Open-source     Started in 1998     Latest version: 1.43...
Boost usage     http://www.boost.org/users/uses.html     Adobe     Google     SAP     McAFee     Real Networks     ...
Boost components for computer vision     Image (GIL)     Graph (BGL)     Thread     Filesystem     uBLAS     Program...
Boost Graph Library     Shortest paths              Dijkstras shortest paths              Bellman-Ford shortest paths  ...
Outline     GIL     Boost     Generic programming     STL     Summary2010 Adobe Systems Incorporated. All Rights Rese...
GIL design principles     Followed the paradigm of generic programming     Clean separation between algorithms and conta...
Generic programming     Programming paradigm for developing efficient, reusable software code     Pioneered by Alexander...
Polymorphism     Allows values of different data types to be handled using a uniform interface     Object-oriented progr...
Generic programming: a case study     Compute the sum of a set of data                                                   ...
Object-oriented style          class int_vector {          private:              int* array;              int n;          ...
Separate the algorithm from the container          int accumulate(int* array, int n) {               int result = 0;      ...
Same algorithm with different types          int accumulate(int* array, int n) {               int result = 0;            ...
C++ templates          template <typename T>          T accumulate(T* array, int n) {               T result = 0;         ...
String concatenation          template <typename T>          T accumulate(T* array, int n) {               T result = 0;  ...
Generalize the interface and type requirements          template <typename T>          T accumulate(T* array, int n, T ini...
Linked list template <typename T> struct list_node {     list_node<T>* next;     T value; }; template <typename T> T accum...
Unifying linked lists and arrays template <typename T>                                  template <typename T> struct list_...
Unifying linked lists and arrays template <typename T>                                  template <typename T> struct list_...
Unifying linked lists and arrays template <typename T>                                  template <typename T> struct list_...
Unifying linked lists and arrays template <typename T>                                  template <typename T> struct list_...
Unifying linked lists and arrays template <typename T>                                  template <typename T> struct list_...
Unifying linked lists and arrays template <typename T>                                  template <typename T> struct list_...
Unifying linked lists and arrays template <typename T>                template <typename T> struct list_node {            ...
Unifying linked lists and arrays template <typename T>                template <typename T> struct list_node {            ...
Unifying linked lists and arrays template <typename T>                template <typename T> struct list_node {            ...
Unified version        template <typename I,                  typename T>        T accumulate(I first, I last, T init) {  ...
Type requirements        template <typename I,                  typename T>        T accumulate(I first, I last, T init) {...
Further generalization with function objects        template <typename I,                  typename T>        T accumulate...
Type requirements       template <typename I,                 typename T,                 typename B>       T accumulate(I...
Function object example    template <typename T>    struct moment_2 {         T m1, m2;         moment_2(T m1_, T m2_) : m...
Function object example    template <typename T>    struct compute_moment_2_s {         moment_2<T> operator()(moment_2<T>...
Lessons learned: #1      Separate between an algorithms and a data structure                                             ...
Lessons learned: #2      Generalize an algorithm to a general form    int accumulate(int* array, int n) {         int res...
Lessons learned: #3      Generalize the interface of an algorithm                      template <typename T>             ...
Lessons learned: #4      Generalize through iteratorstemplate <typename T>T accumulate(list_iterator<T> first,           ...
Lessons learned: #5      Generalize through function objects                                       template <typename I, ...
Concepts/Models     Type requirements     Concept: description of requirements on one or more types stated in terms     ...
Iterators     An interface between sequential data structures and algorithms     Separates containers from algorithms  ...
More models of iterators        template <typename T>                                            template <typename T>    ...
Compilers are working hard for us     C++ compilers resolves all templates at compile time     No dynamic (run-time) dis...
STL     Standard Template Library     http://www.sgi.com/tech/stl     First widespread application of generic programmi...
STL     Containers              vector, list, slist              set, map, multiset, multimap     Algorithms          ...
Summary     GIL     Boost     Generic programming     STL     Code reuse     Better understanding of algorithms    ...
Book recommendation     For those who desire a deep understanding      of programming                                    ...
Upcoming SlideShare
Loading in...5
×

Cvpr2010 open source vision software, intro and training part-iii introduction to gil , boost and generic programming - jin - unknown - 2010

410

Published on

0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
410
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
5
Comments
0
Likes
0
Embeds 0
No embeds

No notes for slide

Transcript of "Cvpr2010 open source vision software, intro and training part-iii introduction to gil , boost and generic programming - jin - unknown - 2010"

  1. 1. Introduction to GIL,Boost and GenericProgrammingHailin JinAdvanced Technology LabsAdobe Systems Incorporatedhttp://www.adobe.com/technology/people/sanjose/jin.html 12010 Adobe Systems Incorporated. All Rights Reserved.
  2. 2. Outline GIL Boost Generic programming STL Summary2010 Adobe Systems Incorporated. All Rights Reserved.
  3. 3. What is GIL? Generic Image Library C++ image library Open-source http://opensource.adobe.com/gil Well documented The core library only contains header files; No need to link anything Thread-safe Compatible with most C++ compilers (Visual Studio, gcc, etc)2010 Adobe Systems Incorporated. All Rights Reserved.
  4. 4. GIL overview Image containers 1-D iterators for traversing rows and columns 2-D iterators (locator) for arbitrary 2D traversal Image views Image processing algorithms Extensions  io extension for reading and writing images of popular formats (PNG, JPEG, TIFF, …) rgb8_image_t im; read_png_image("test.png", im);  numeric extension for convolutions against fixed and variable-size kernels kernel_1d_fixed<float, 7> kernel; gray8_image_t im_in, im_out; convolve_rows_fixed<gray32f_pixel_t>(const_view(im_in), kernel, view(im_out));2010 Adobe Systems Incorporated. All Rights Reserved.
  5. 5. People Lubomir Bourdev Hailin Jin Christian Henning Adobe Adobe Independent2010 Adobe Systems Incorporated. All Rights Reserved.
  6. 6. GIL history Started as an Adobe internal project in 2005 Version 1.0 in June 2006 Accepted into Boost in November 2006 Version 2.0 in March 2007 Constantly updated and patched with Boost releases2010 Adobe Systems Incorporated. All Rights Reserved.
  7. 7. License Initially: MIT license Currently: Boost Software License (similar to the MIT license) Free to use, reproduce, display, distribute, execute, and transmit, including derivative works We retain the copyright2010 Adobe Systems Incorporated. All Rights Reserved.
  8. 8. Image processing libraries Your own image libraries OpenCV CImg Vigra GIL works third-party algorithms, libraries, etc2010 Adobe Systems Incorporated. All Rights Reserved.
  9. 9.  http://www.boost.org High-quality C++ libraries Open-source Started in 1998 Latest version: 1.43.0 on May 6, 2010 Strict review system 10 of the Boost libraries are included in the C++ Standard Library TR “It is usually a really dumb idea to go and reinvent a wheel that Boost already offers. ” — Bjarne Stroustrup, inventor of C++2010 Adobe Systems Incorporated. All Rights Reserved.
  10. 10. Boost usage http://www.boost.org/users/uses.html Adobe Google SAP McAFee Real Networks …2010 Adobe Systems Incorporated. All Rights Reserved.
  11. 11. Boost components for computer vision Image (GIL) Graph (BGL) Thread Filesystem uBLAS Program options Math related libraries2010 Adobe Systems Incorporated. All Rights Reserved.
  12. 12. Boost Graph Library Shortest paths  Dijkstras shortest paths  Bellman-Ford shortest paths  Johnsons all-Pairs shortest paths Minimum spanning trees  Kruskals minimum spanning tree  Prims minimum spanning tree Connected components  Connected components  Strongly connected components Maximum flow  Edmonds Karp  Push-relabel  Kolmogorov Topological sort, sparse matrix ordering, and many more2010 Adobe Systems Incorporated. All Rights Reserved.
  13. 13. Outline GIL Boost Generic programming STL Summary2010 Adobe Systems Incorporated. All Rights Reserved.
  14. 14. GIL design principles Followed the paradigm of generic programming Clean separation between algorithms and containers Work with third-party algorithms, data structures, and libraries Toward optimal performance2010 Adobe Systems Incorporated. All Rights Reserved.
  15. 15. Generic programming Programming paradigm for developing efficient, reusable software code Pioneered by Alexander Stepanov and David Musser First successful example is the Standard Template Library (STL) which is now part of the C++ standard Programming based on parameterization  Parameterize a data structure with different types (example: a std::vector<> with its element types)  Parameterize an algorithm with different types and algorithms (example: std::sort() function for int* and float* and with a comparison function) Generalize an algorithm or data structure to its most general and useful form  Better code  Fewer bugs2010 Adobe Systems Incorporated. All Rights Reserved.
  16. 16. Polymorphism Allows values of different data types to be handled using a uniform interface Object-oriented programming (OOP)  Ad-hoc polymorphism  Class hierarchies: specified inheritance  Function/method overloading: different and potentially heterogeneous implementations depending on a limited range of individually specified types and combinations  Dynamic dispatch Generic programming  Parametric polymorphism (data structure and algorithms)  Code is written without mention of any specific type and thus can be used transparently with any number of new types  Static (compile-time) dispatch2010 Adobe Systems Incorporated. All Rights Reserved.
  17. 17. Generic programming: a case study Compute the sum of a set of data 172010 Adobe Systems Incorporated. All Rights Reserved.
  18. 18. Object-oriented style class int_vector { private: int* array; int n; ... public: ... int accumulate() { int result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; return result; } ... };2010 Adobe Systems Incorporated. All Rights Reserved.
  19. 19. Separate the algorithm from the container int accumulate(int* array, int n) { int result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; return result; } class int_vector { private: int* array; int n; ... public: ... int size() {return n;} int* begin() {return array;} ... }; int_vector a_vec; int result = accumulate(a_vec.begin(), a_vec.size());2010 Adobe Systems Incorporated. All Rights Reserved.
  20. 20. Same algorithm with different types int accumulate(int* array, int n) { int result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; return result; } float accumulate(float* array, int n) { float result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; return result; }2010 Adobe Systems Incorporated. All Rights Reserved.
  21. 21. C++ templates template <typename T> T accumulate(T* array, int n) { T result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; return result; }2010 Adobe Systems Incorporated. All Rights Reserved.
  22. 22. String concatenation template <typename T> T accumulate(T* array, int n) { T result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; return result; } std::string concatenate(std::string* array, int n) { std::string result = ””; for (int i = 0; i < n; ++i) result = result + array[i]; return result; } template <typename T> T accumulate(T* array, int n) { T result = T(); T result; for (int i = 0; i < n; ++i) result = result + array[i]; return result; }2010 Adobe Systems Incorporated. All Rights Reserved.
  23. 23. Generalize the interface and type requirements template <typename T> T accumulate(T* array, int n, T init) { for (int i = 0; i < n; ++i) init = init + array[i]; return init; } Type requirements on T • T must have a copy constructor T(const T&) • T must have an assignment operator=() • T must have a binary operator+(,)2010 Adobe Systems Incorporated. All Rights Reserved.
  24. 24. Linked list template <typename T> struct list_node { list_node<T>* next; T value; }; template <typename T> T accumulate(list_node<T>* first, T init) { while (first!=0) { init = init + first->value; first = first->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  25. 25. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* array, int n, T init) { list_node<T>* next; for (int i = 0; i < n; ++i) T value; init = init + array[i]; }; return init; } template <typename T> T accumulate(list_node<T>* first, T init) { while (first!=0) { init = init + first->value; first = first->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  26. 26. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, int n, T init) { list_node<T>* next; T* last = first + n; T value; for (;first!=last;++first) { }; init = init + *first; } template <typename T> return init; T accumulate(list_node<T>* first, } T init) { while (first!=0) { init = init + first->value; first = first->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  27. 27. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, int n, T init) { list_node<T>* next; T* last = first + n; T value; while (first!=last) { }; init = init + *first; ++first; template <typename T> } T accumulate(list_node<T>* first, return init; T init) { } while (first!=0) { init = init + first->value; first = first->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  28. 28. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, T* last, T init) { list_node<T>* next; while (first!=last) { T value; init = init + *first; }; ++first; } template <typename T> return init; T accumulate(list_node<T>* first, } T init) { while (first!=0) { init = init + first->value; first = first->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  29. 29. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, T* last, T init) { list_node<T>* next; while (first!=last) { T value; init = init + *first; }; ++first; } template <typename T> return init; struct list_iterator { } list_node<T>* node; }; template <typename T> T accumulate(list_iterator<T> first, T init) { while (first.node!=0) { init = init + first.node->value; first.node = first.node->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  30. 30. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, T* last, T init) { list_node<T>* next; while (first!=last) { T value; init = init + *first; }; ++first; } template <typename T> return init; struct list_iterator { } list_node<T>* node; }; template <typename T> T accumulate(list_iterator<T> first, list_iterator<T> last, T init) { while (first!=last) { init = init + first.node->value; first.node = first.node->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  31. 31. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, T* last, T init) { list_node<T>* next; while (first!=last) { T value; init = init + *first; }; ++first; } template <typename T> return init; struct list_iterator { } list_node<T>* node; template <typename T> }; bool operator!=(list_iterator<T> x, list_iterator<T> y) { template <typename T> return x.node!=y.node; T accumulate(list_iterator<T> first, } list_iterator<T> last, T init) { while (first!=last) { init = init + first.node->value; first.node = first.node->next; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  32. 32. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, T* last, T init) { list_node<T>* next; while (first!=last) { T value; init = init + *first; }; ++first; } template <typename T> return init; struct list_iterator { } list_node<T>* node; template <typename T> }; bool operator!=(list_iterator<T> x, list_iterator<T> y) { template <typename T> return x.node!=y.node; T accumulate(list_iterator<T> first, } list_iterator<T> last, T init) { template <typename T> while (first!=last) { T operator*(list_iterator<T> x) { init = init + first.node->value; return x.node->value; first.node = first.node->next; } } return init; template <typename T> } list_iterator<T>& operator++(list_iterator<T>& x) { x.node = x.node->next; return x; }2010 Adobe Systems Incorporated. All Rights Reserved.
  33. 33. Unifying linked lists and arrays template <typename T> template <typename T> struct list_node { T accumulate(T* first, T* last, T init) { list_node<T>* next; while (first!=last) { T value; init = init + *first; }; ++first; } template <typename T> return init; struct list_iterator { } list_node<T>* node; template <typename T> }; bool operator!=(list_iterator<T> x, list_iterator<T> y) { template <typename T> return x.node!=y.node; T accumulate(list_iterator<T> first, } list_iterator<T> last, T init) { template <typename T> while (first!=last) { T operator*(list_iterator<T> x) { init = init + *first; return x.node->value; ++first; } } return init; template <typename T> } list_iterator<T>& operator++(list_iterator<T>& x) { x.node = x.node->next; return x; }2010 Adobe Systems Incorporated. All Rights Reserved.
  34. 34. Unified version template <typename I, typename T> T accumulate(I first, I last, T init) { while (first!=last) { init = init + *first; ++first; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  35. 35. Type requirements template <typename I, typename T> T accumulate(I first, I last, T init) { while (first!=last) { init = init + *first; ++first; } return init; } • I must have a copy constructor I(const I&) • I must have a binary operator!=(,) • I must have an operator*() • I must have an operator++() • T must have a copy constructor T(const T&) • T must have an assignment operator=() • T must have a binary operator+(,)2010 Adobe Systems Incorporated. All Rights Reserved.
  36. 36. Further generalization with function objects template <typename I, typename T> T accumulate(I first, I last, T init) { while (first!=last) { init = init + *first; ++first; } return init; } template <typename I, typename T, typename B> T accumulate(I first, I last, T init, B op) { while (first!=last) { init = op(init, *first); ++first; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  37. 37. Type requirements template <typename I, typename T, typename B> T accumulate(I first, I last, T init, B op) { while (first!=last) { init = op(init, *first); ++first; } • I must have a copy constructor I(const I&) return init; } • I must have a binary operator!=(,) • I must have an operator*() • I must have an operator++() • T must have a copy constructor T(const T&) • T must have an assignment operator=() • B must have a copy constructor B(const B&) • B must have a binary application operator()(,)2010 Adobe Systems Incorporated. All Rights Reserved.
  38. 38. Function object example template <typename T> struct moment_2 { T m1, m2; moment_2(T m1_, T m2_) : m1(m1_), m2(m2_) {} }; template <typename T> moment_2<T> compute_moment_2(T* first, T* last, moment_2<T> init) { while (first!=last) { init.m1 += *first; init.m2 += *first**first; ++first; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  39. 39. Function object example template <typename T> struct compute_moment_2_s { moment_2<T> operator()(moment_2<T> m, T x) const { m.m1 += x; m.m2 += x*x; return m; } }; template <typename T> moment_2<T> compute_moment_2(T* first, T* last, moment_2<T> init) { return accumulate(first, last, init, compute_moment_2_s<T>()); } template <typename T> struct max_s { T operator()(T x, T y) const {return x>y?x:y;} }; template <typename T> T range_max(T* first, T* last, T init) { return accumulate(first, last, init, max_s()); }2010 Adobe Systems Incorporated. All Rights Reserved.
  40. 40. Lessons learned: #1 Separate between an algorithms and a data structure int accumulate(int* array, int n) { int result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; class int_vector { return result; private: } int* array; int n; class int_vector { ... private: public: int* array; ... int n; int accumulate() { ... int result = 0; public: for (int i = 0; i < n; ++i) ... result = result + array[i]; int size() {return n;} int* begin() {return array;} return result; ... } }; ... }; int_vector a_vec; int result = accumulate(a_vec.begin()2010 Adobe Systems Incorporated. All Rights Reserved.
  41. 41. Lessons learned: #2 Generalize an algorithm to a general form int accumulate(int* array, int n) { int result = 0; for (int i = 0; i < n; ++i) result = result + array[i]; template <typename T> return result; T accumulate(T* array, int n) { } T result = T(); for (int i = 0; i < n; ++i) float accumulate(float* array, int n) { result = result + array[i]; float result = 0; return result; for (int i = 0; i < n; ++i) } result = result + array[i]; return result; }2010 Adobe Systems Incorporated. All Rights Reserved.
  42. 42. Lessons learned: #3 Generalize the interface of an algorithm template <typename T> T accumulate(T* array, int n) { T result = T(); for (int i = 0; i < n; ++i) result = result + array[i]; return result; } template <typename T> T accumulate(T* array, int n, T init) { for (int i = 0; i < n; ++i) init = init + array[i]; return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  43. 43. Lessons learned: #4 Generalize through iteratorstemplate <typename T>T accumulate(list_iterator<T> first, T init) { while (first!=0) { init = init + first.node->value; template <typename I, first.node = first.node->next; typename T> } T accumulate(I first, I last, T init) { return init; while (first!=last) {} init = init + *first; ++first;template <typename T> }T accumulate(T* array, int n, T init) { return init; for (int i = 0; i < n; ++i) } init = init + array[i]; return init;}2010 Adobe Systems Incorporated. All Rights Reserved.
  44. 44. Lessons learned: #5 Generalize through function objects template <typename I, typename T> T accumulate(I first, I last, T init) { while (first!=last) { init = init + *first; ++first; } return init; } template <typename I, typename T, typename B> T accumulate(I first, I last, T init, B op) { while (first!=last) { init = op(init, *first); ++first; } return init; }2010 Adobe Systems Incorporated. All Rights Reserved.
  45. 45. Concepts/Models Type requirements Concept: description of requirements on one or more types stated in terms of the existence and properties of procedures, type attributes, and type functions defined on the types Model: satisfies all the requirements of a concept Example Concept • T must have a copy constructor T(const T&)template <typename T>T accumulate(T* array, int n, T init) { • T must have an assignment operator=() for (int i = 0; i < n; ++i) • T must have a binary operator+(,) init = init + array[i]; return init; Model} • int, float, std::string, … Concepts are not designed or invented. Instead they are discovered2010 Adobe Systems Incorporated. All Rights Reserved.
  46. 46. Iterators An interface between sequential data structures and algorithms Separates containers from algorithms Models: raw points and linked list iterators template <typename I, typename T> T accumulate(I first, I last, T init) { while (first!=last) { init = init + *first; ++first; } return init; } • I must have a copy constructor I(const I&) • I must have a binary operator!=(,) • I must have operator*() • I must have operator++()2010 Adobe Systems Incorporated. All Rights Reserved.
  47. 47. More models of iterators template <typename T> template <typename T> class step_pointer { class indirect_pointer { privte: privte: T* x; T* x; int step; int* y; public: public: ... ... T operator*() {return *x;} T operator*() {return x[*y];} step_pointer& operator++() { step_pointer& operator++() { x += step; return *this; ++y; return *this; } } ... ... }; }; template <typename T> class value_iterator { privte: T x; public: ... T operator*() {return x;} step_pointer& operator++() { ++x; return *this; } ... }; 472010 Adobe Systems Incorporated. All Rights Reserved.
  48. 48. Compilers are working hard for us C++ compilers resolves all templates at compile time No dynamic (run-time) dispatch Function objects can be inlined; No function calls overhead2010 Adobe Systems Incorporated. All Rights Reserved.
  49. 49. STL Standard Template Library http://www.sgi.com/tech/stl First widespread application of generic programming Part of the C++ standard Containers Iterators Algorithms2010 Adobe Systems Incorporated. All Rights Reserved.
  50. 50. STL Containers  vector, list, slist  set, map, multiset, multimap Algorithms  find(), for_each(), fill(), transform(), copy()  partition(), stable_partition()  sort(), lower_bound(), nth_element(), merge()  set_difference(), set_union(), set_intersection()  accumulate(), inner_product(), partial_sum()2010 Adobe Systems Incorporated. All Rights Reserved.
  51. 51. Summary GIL Boost Generic programming STL Code reuse Better understanding of algorithms Better code2010 Adobe Systems Incorporated. All Rights Reserved.
  52. 52. Book recommendation For those who desire a deep understanding of programming 522010 Adobe Systems Incorporated. All Rights Reserved.
  1. A particular slide catching your eye?

    Clipping is a handy way to collect important slides you want to go back to later.

×