Here are a few scattered thoughts.

  SWIG.  Inline vs.  Perhaps as an appendix.

  "The Gory Details" may need to be pulled apart.  If there ends up
  being a tension between "random user who just wants to use Inline"
  vs "aggressive detail-oriented user".

  "person trying to answer a question" might be another target
  audience / reader role.

  And an "Inline for sysadmins" chunk.  So they don't have to grovel
  over the whole book to pull out the bits they care about.

  Generalizing, once one has approached something from a `decompose
  the concept space' direction, it is often useful to take another
  pass at it from a `decompose the user population / user
  role-of-the-moment' direction.

  Run-time code generation.  (As long as someone other than me is
  finding it useful... :).

  Standalone vs integrated use.  Ie, does the user call Inline
  themselves, or hand off their code to a domain object (which can
  then add headers (thus providing a specialized api), play code
  modification games, etc).  Eg, PyInline vs SciPy's Weave.  

  Hmm.  Why is PyInline stagnating, but perl's Inline not?  Why are
  performance intensive Python modules using RTCG, but Perl's not.

  Discuss all the usual complaints about / difficulties with, inlined
  and multilingual programming.

  Development hints and tools.  Emacs MMM mode.

  Using Inline with mumble.  GD, PDL, Qt, wxPerl.  Etc.
  And hints on using Inline with preexisting Perl C/C++ wrapper classes.

  Multilingual objects as a unified topic.  Deciding where to slice.
  Where should the data go?  Accessing data in both directions.  Mixed
  approaches.  Helper objects.  Where should procedural functionality
  go?  Helper functions.  Separating the common case.  Duplicate
  implementations.  Much of this will show up elsewhere in the book,
  but I suspect it really needs to be pulled together, at least by
  reference, in order to make sense.

  Objects with C APIs.  "Compile" vs "run"-time approaches.  Eg,
  Python's CObjects vs exporting headers.
  Dealing with C/C++ pointers in perl.

  Getting garbage collection / memory management right.  Tips and
  tricks.

  Profiling.  Inline performance characteristics.  The insanity of
  premature optimization.

  When _NOT_ to use Inline.  Development-process-level pitfalls and
  perils.  How to recognize when you are losing and what to do about it.

  Generalizing- the art of managing the C/Perl boundry.

Random thoughts,
Mitchell Charity

Reply via email to