<?xml version="1.0" encoding="utf-8"?>
<!-- generator="FeedCreator 1.7.2-ppt DokuWiki" -->
<?xml-stylesheet href="http://www.music.mcgill.ca/~sinclair/content/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="http://www.music.mcgill.ca/~sinclair/content/feed.php">
        <title>Stevebook</title>
        <description></description>
        <link>http://www.music.mcgill.ca/~sinclair/content/</link>
        <image rdf:resource="http://www.music.mcgill.ca/~sinclair/content/lib/images/favicon.ico" />
       <dc:date>2011-05-22T15:03:21-04:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/comparing_c_0x_lambdas_with_scheme_an_object_with_mutable_state_no_classes_involved"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/libmapper_is_the_unix_utilities_of_mapping"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/liquid_simulator_ported_to_canvas"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/the_clay_programming_language_seems_pretty_nice"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/using_markdown_for_beamer_presentations"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/caprica_is_actually_pretty_awesome"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/calling_haskell_from_a_pure_data_external"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/the_rules_of_programming"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/double-buffered_state_as_a_clojure-style_approach_to_parallelism_for_simulation"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/hapstick_haptic_billiards"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/a_functional_game_loop_for_glut_in_scheme_using_continuations"/>
                <rdf:li rdf:resource="http://www.music.mcgill.ca/~sinclair/content/blog/legality_of_unsolicited_but_open_wifi_access"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="http://www.music.mcgill.ca/~sinclair/content/lib/images/favicon.ico">
        <title>Stevebook</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/</link>
        <url>http://www.music.mcgill.ca/~sinclair/content/lib/images/favicon.ico</url>
    </image>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/comparing_c_0x_lambdas_with_scheme_an_object_with_mutable_state_no_classes_involved">
        <dc:format>text/html</dc:format>
        <dc:date>2011-05-21T14:47:04-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:comparing_c_0x_lambdas_with_scheme_an_object_with_mutable_state_no_classes_involved - created</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/comparing_c_0x_lambdas_with_scheme_an_object_with_mutable_state_no_classes_involved</link>
        <description></description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/libmapper_is_the_unix_utilities_of_mapping">
        <dc:format>text/html</dc:format>
        <dc:date>2011-02-19T18:48:15-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:libmapper_is_the_unix_utilities_of_mapping - created</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/libmapper_is_the_unix_utilities_of_mapping</link>
        <description>libmapper is the unix utilities of mapping


I've been trying to put into more concrete terms why I think
libmapper is a useful
development.  After all, there are plenty of systems that allow
connecting boxes to each other and describing how data should flow and
be transformed, which effectively is what libmapper provides.</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/liquid_simulator_ported_to_canvas">
        <dc:format>text/html</dc:format>
        <dc:date>2010-12-15T11:16:04-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:liquid_simulator_ported_to_canvas</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/liquid_simulator_ported_to_canvas</link>
        <description>I ported to JavaScript/Canvas the Flash version of this liquid simulator that has popped up on Reddit lately.

The original Java version can be found here.  My JavaScript source can be found here.</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/the_clay_programming_language_seems_pretty_nice">
        <dc:format>text/html</dc:format>
        <dc:date>2010-12-15T11:12:56-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:the_clay_programming_language_seems_pretty_nice</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/the_clay_programming_language_seems_pretty_nice</link>
        <description>Always after doing a certain amount of C programming I get the itch
that it would be great if only it were a little nicer.  I'm
actually pretty comfortable with pointers and strings and nulls, and
all the dangers that come with this stuff.  But what I'd really
like are more ways to take advantage of strong typing, and ways to
avoid code duplication without resorting the void*, i.e., losing
all typing just to do some generic programming.  Due to the need for
void*, generic programming in C tends …</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/using_markdown_for_beamer_presentations">
        <dc:format>text/html</dc:format>
        <dc:date>2010-03-29T13:00:23-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:using_markdown_for_beamer_presentations - created</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/using_markdown_for_beamer_presentations</link>
        <description>I've recently had to make another presentation, and since I'm now
fully into a LaTeX-oriented workflow
when it comes to documents,
Beamer is my choice.

However, one thing I hate is the verbosity of the markup.  Fortunately
there are a bunch of “minimalized” markup languages that can help
resolve this problem.  One is the well-known
Markdown.  I actually
think it's one of the less powerful textual markup languages, but it's
somehow one of the most popular.</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/caprica_is_actually_pretty_awesome">
        <dc:format>text/html</dc:format>
        <dc:date>2010-03-14T21:21:57-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:caprica_is_actually_pretty_awesome - created</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/caprica_is_actually_pretty_awesome</link>
        <description>*  Warning: Don't read this if you haven't watched the finale of Battlestar.  I'd also recommend watching at least the pilot of Caprica before reading.


So I finally decided to sit down and check out
Caprica.  I
had put it off because I fall into the camp of those who were a little
disapointed by the finale of
Battlestar
Galactica and didn't particularly want to give the writers another
chance.</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/calling_haskell_from_a_pure_data_external">
        <dc:format>text/html</dc:format>
        <dc:date>2009-12-08T00:20:13-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:calling_haskell_from_a_pure_data_external</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/calling_haskell_from_a_pure_data_external</link>
        <description>[Screenshot of the Pd external object featuring Haskell function calls. ]

I've been playing lately with an idea for a 
Pure Data external that involves a certain amount of structured data
manipulation, and started to wonder if it might be easier to use a
higher level language than C.  I don't really want to make this a
massive external with huge crazy dependencies though, so I started
looking at very small Lisps that I could embed or that compile to C.
I had a certain amount of success with Gam…</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/the_rules_of_programming">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-19T16:37:37-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:the_rules_of_programming - created</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/the_rules_of_programming</link>
        <description>I just wanted to share what I thought was a very insightful
comment
from
reddit (user munificient).  He was talking about why young
programmers tend to take best-practises guidelines as the rule of
law instead of thinking more clearly about design decisions:</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/double-buffered_state_as_a_clojure-style_approach_to_parallelism_for_simulation">
        <dc:format>text/html</dc:format>
        <dc:date>2009-10-07T17:06:12-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:double-buffered_state_as_a_clojure-style_approach_to_parallelism_for_simulation</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/double-buffered_state_as_a_clojure-style_approach_to_parallelism_for_simulation</link>
        <description>Clojure is a Lisp dialect that has effectively
solved the problem of programming applications involving a high degree
of paralellism.  It's of course bold to claim that this is “solved”,
but I strongly believe that Clojure's approach to identity as
described by Hickey is the right approach to this issue.  Not only
does it make parallelism easier, but the functional approach makes for
better and more modular software design than object oriented
approaches.  I won't argue this in depth here, but f…</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/hapstick_haptic_billiards">
        <dc:format>text/html</dc:format>
        <dc:date>2009-09-16T15:11:55-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:hapstick_haptic_billiards</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/hapstick_haptic_billiards</link>
        <description>Not new, but I just came across this.  I've thought of doing something similar using off-the-shelf hardware (Phantom, Freedom 6S, etc.). but I sure am glad someone took the time to implement this for real. :)



Here's a link to the HapStick project homepage.</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/a_functional_game_loop_for_glut_in_scheme_using_continuations">
        <dc:format>text/html</dc:format>
        <dc:date>2009-09-10T01:22:34-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:a_functional_game_loop_for_glut_in_scheme_using_continuations - created</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/a_functional_game_loop_for_glut_in_scheme_using_continuations</link>
        <description>Lately I have decided to learn more about functional programming.
I've become very attracted to the elegance of ideas about lazy
evaluation and immutability and expression of a program in terms of
pure functions.  In particular I am drawn to the idea of describing a
program in terms of streams, also called lazy lists.  I think about
simulation problems a lot---game loops, if you want---and I wanted to
see how I might write “time step”-oriented programs in a functional
language.  I really like th…</description>
    </item>
    <item rdf:about="http://www.music.mcgill.ca/~sinclair/content/blog/legality_of_unsolicited_but_open_wifi_access">
        <dc:format>text/html</dc:format>
        <dc:date>2009-04-13T19:19:32-04:00</dc:date>
        <dc:creator>Stephen Sinclair</dc:creator>
        <title>blog:legality_of_unsolicited_but_open_wifi_access</title>
        <link>http://www.music.mcgill.ca/~sinclair/content/blog/legality_of_unsolicited_but_open_wifi_access</link>
        <description>Legality of unsolicited but open WiFi access


I don't usually write about legal issues, but last night I had a
conversation where someone mentioned that “someone had told them” that
it's illegal in Canada to connect to someone's open WiFi without their
permission.  I was surprised by this pronouncement since I had
understood that it was still a very unsettled and widely debated
issue, and furthermore I hadn't heard anything about specific cases in
Canada.  Well, I hate to see legal knowledge be…</description>
    </item>
</rdf:RDF>

