<rss xmlns:itunes="http://www.itunes.com/dtds/podcast-1.0.dtd" version="2.0">
  <channel>
    <title>MaplePrimes - comments on Post, Fran Allen Lecture</title>
    <link>http://www.mapleprimes.com/posts/36217-Fran-Allen-Lecture</link>
    <language>en-us</language>
    <copyright>2026 Maplesoft, A Division of Waterloo Maple Inc.</copyright>
    <generator>Maplesoft Document System</generator>
    <lastBuildDate>Wed, 10 Jun 2026 17:38:43 GMT</lastBuildDate>
    <pubDate>Wed, 10 Jun 2026 17:38:43 GMT</pubDate>
    <itunes:subtitle />
    <itunes:summary />
    <description>The latest comments added to the Post, Fran Allen Lecture</description>
    <image>
      <url>http://www.mapleprimes.com/images/mapleprimeswhite.jpg</url>
      <title>MaplePrimes - comments on Post, Fran Allen Lecture</title>
      <link>http://www.mapleprimes.com/posts/36217-Fran-Allen-Lecture</link>
    </image>
    <item>
      <title>high performance computing</title>
      <link>http://www.mapleprimes.com/posts/36217-Fran-Allen-Lecture?ref=Feed:MaplePrimes:Fran Allen Lecture:Comments#comment61239</link>
      <itunes:summary>Thanks for the interesting post.  I have a few random thoughts:

On lack of caches, this is basically a GPU.  Makes a lot of sense for intensive branch free computations, e.g. linear algebra, simulations, plotting, signal processing.  Basically dense computations requiring high throughput.  It uses die area for arithmetic units instead of cache.

For general purpose computing however, caches are never going away.  Branches = caches.  What you can expect to see is more of the following: &lt;a href="http://arstechnica.com/hardware/news/2009/11/amd-bobcat-bulldozer.ars"&gt;shared resources&lt;/a&gt; across multiple execution cores.  We're going to get *a lot* of cores.  Thousands.  But the caches will be shared, so high performance design will become even more important.  The decode and L1 instruction caches on Bulldozer are shared.  That means you want to run the same program on each core if at all possible.

As for smart compilers, I think this is basically wrong.  Smart compilers have never really worked.  They were supposed to make RISC more efficient.  They were also supposed to make functional languages faster than C.  I think people underestimate compilers' ability to choose good instructions, and massively overestimate their ability to make a good program.  You can not automate design.

I think the future does not belong to any one solution.  I think you'll see old low level techniques dusted off and used for fine grained parallelization of operations.  Programmer tools, like the task model, will be used to parallelize non-uniform algorithms.  And high level languages like Maple will wield this power automatically, driven by everything underneath.  Nobody wants to write parallel software.  The future is automatic.</itunes:summary>
      <description>The latest comments added to the Post, Fran Allen Lecture</description>
      <guid>61239</guid>
      <pubDate>Sat, 05 Dec 2009 00:53:57 Z</pubDate>
      <itunes:author>roman_pearce</itunes:author>
      <author>roman_pearce</author>
    </item>
    <item>
      <title>So, from the users point of view</title>
      <link>http://www.mapleprimes.com/posts/36217-Fran-Allen-Lecture?ref=Feed:MaplePrimes:Fran Allen Lecture:Comments#comment61240</link>
      <itunes:summary>&lt;p&gt;If I get to vote, my preference would be for Maple to fix the problems with the multi-threaded code and to get good support for compiled CUDA (or whatever) programs for those of us with GPU's.&amp;nbsp; Since a lot of what I do is linear algebra (double precision numerics) being to offload matrix multiplies and the construction of big matrices to the GPU would be a **big** win.&amp;nbsp; Obviously, being compiler and linker averse (not incapable -- just averse) being able to compile Maple code to CUDA code (even if I have to be careful about writing the code as I do now with Compiler:-Compile() ) and then run it from Maple (using define_external) would be heaven.&amp;nbsp;&lt;/p&gt;
&lt;p&gt;I know having a wonderful general solution for adding high-level language support would be great; however, getting this basic level of support into the next beta would solve a lot of my problems right away.&lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Fran Allen Lecture</description>
      <guid>61240</guid>
      <pubDate>Mon, 07 Dec 2009 05:53:45 Z</pubDate>
      <itunes:author>marvin</itunes:author>
      <author>marvin</author>
    </item>
    <item>
      <title>DSLs</title>
      <link>http://www.mapleprimes.com/posts/36217-Fran-Allen-Lecture?ref=Feed:MaplePrimes:Fran Allen Lecture:Comments#comment61241</link>
      <itunes:summary>&lt;p&gt;I completely agree with Allen on the future of DSLs, and how the higher-level they are, the easier it is to optimize them tons.&amp;nbsp; [Disagreeing with a Turing award winner is usually foolhardy and requires a lot of proof, else it's hardly credible].&lt;/p&gt;
&lt;p&gt;Anyways, I've actually been working on this quite intensively for the past few years, and I'm totally convinced it works.&amp;nbsp; The main problem is that few programmers have any real clue what 'high level' really means!&amp;nbsp; In the Maple world, there is an easy example: a MapleSim diagram is sufficiently high-level.&amp;nbsp; Anything lower-level than that contains too many 'operational' details.&amp;nbsp; I guess another example would be the rubber-band model of placement for Maplets.&amp;nbsp; Properly written LaTeX would also qualify as reasonably high-level, but few people ever write 'proper' LaTeX, mostly because few people really understand Model-View-Controller well enough to understand how to separate model and view.&amp;nbsp; At least the web people eventually got it right (a proper web page uses CSS for the view aspects and XML for the model).&amp;nbsp; While the syntax of CSS is not great, it is conceptually a really good DSL for what it does.&lt;/p&gt;
&lt;p&gt;The point about being able to do program analysis is also quite non-trivial: to be able to do that requires really and clear solid semantics for the language.&amp;nbsp; Unfortunately, for Maple (see my ex-student Stephen Forrest's work on the topic), it's just too bloody hard.&amp;nbsp; Maple's programming language has a very messy operational semantics, which means that it's extremely hard to analyze with any degree of precision. &lt;/p&gt;</itunes:summary>
      <description>The latest comments added to the Post, Fran Allen Lecture</description>
      <guid>61241</guid>
      <pubDate>Tue, 08 Dec 2009 05:52:40 Z</pubDate>
      <itunes:author>JacquesC</itunes:author>
      <author>JacquesC</author>
    </item>
  </channel>
</rss>