Created
January 22, 2020 06:54
-
-
Save pyrmont/eeca4bd867d1bc93647f1fbb49ea7c8b to your computer and use it in GitHub Desktop.
blog.danieljanus.pl Atom Feed
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| <?xml version="1.0" encoding="UTF-8"?> | |
| <a:feed xmlns:a="http://www.w3.org/2005/Atom"> | |
| <a:id>tag:blog.danieljanus.pl,2019:feed</a:id> | |
| <a:title>code · words · emotions: Daniel Janus’s blog</a:title> | |
| <a:link href="http://blog.danieljanus.pl"/> | |
| <a:updated>2020-01-21T00:00:00Z</a:updated> | |
| <a:author> | |
| <a:name>Daniel Janus</a:name> | |
| <a:uri>http://danieljanus.pl</a:uri> | |
| <a:email>dj@danieljanus.pl</a:email> | |
| </a:author> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2020-01-21:post:middleware</a:id> | |
| <a:title>Careful with that middleware, Eugene</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2020/01/21/middleware/"/> | |
| <a:updated>2020-01-21T00:00:00Z</a:updated> | |
| <a:content type="html"><h2>Prologue</h2><p>I’ll be releasing version 0.3 of <a href='https://github.com/nathell/skyscraper'>Skyscraper</a>, my Clojure framework for scraping entire sites, in a&nbsp;few days.</p><p>More than three years have passed since its last release. During that time, I’ve made a&nbsp;number of attempts at redesigning it to&nbsp;be more robust, more usable, and faster; the last one, resulting in an almost complete rewrite, is now almost ready for public use as I’m ironing out the rough edges, documenting it, and adding tests.</p><p>It’s been a&nbsp;long journey and I’ll blog about it someday; but today, I’d like to&nbsp;tell another story: one of a&nbsp;nasty bug I&nbsp;had encountered.</p><h2>Part One: Wrap, wrap, wrap, wrap</h2><p>While updating the code of one of my old scrapers to&nbsp;use the API of Skyscraper 0.3, I&nbsp;noticed an odd thing: some of the output records contained scrambled text. Apparently, the character encoding was not recognised properly.</p><p>“Weird,” I&nbsp;thought. Skyscraper should be extra careful about honoring the encoding of pages being scraped (declared either in the headers, or the <code>&lt;meta http-equiv&gt;</code> tag). In fact, I&nbsp;remembered having seen it working. What was wrong?</p><p>For every page that it downloads, Skyscraper 0.3 caches the HTTP response body along with the headers so that it doesn’t have to&nbsp;be downloaded again; the headers are needed to&nbsp;ensure proper encoding when parsing a&nbsp;cached page. The headers are lower-cased, so that Skyscraper can then call <code>&#40;get all-headers &quot;content-type&quot;&#41;</code> to&nbsp;get the encoding declared in headers. If this step is missed, and the server returns the encoding in a&nbsp;header named <code>Content-Type</code>, it won’t be matched. Kaboom!</p><p>I&nbsp;looked at the cache, and sure enough, the header names in the cache were not lower-cased, even though they should be. But why?</p><p>Maybe I&nbsp;was mistaken, and I&nbsp;had forgotten the lower-casing after all? A&nbsp;glance at the code: no. The lower-casing was there, right around the call to&nbsp;the download function.</p><p>Digression: Skyscraper uses <a href='https://github.com/dakrone/clj-http'>clj-http</a> to&nbsp;download pages. clj-http, in turn, uses the <a href='http://clojure-doc.org/articles/cookbooks/middleware.html'>middleware pattern</a>: there’s a&nbsp;“bare” request function, and then there are wrapper functions that implement things like redirects, OAuth, exception handling, and what have you. I&nbsp;say “wrapper” because they literally wrap the bare function: <code>&#40;wrap-something request&#41;</code> returns another function that acts just like <code>request</code>, but with added functionality. And that other function can in turn be wrapped with yet another one, and so on.</p><p>There’s a&nbsp;default set of middleware wrappers defined by clj-http, and it also provides a&nbsp;macro, <code>with-additional-middleware</code>, which allows you to&nbsp;specify additional wrappers. One such wrapper is <code>wrap-lower-case-headers</code>, which, as the name suggests, causes the response’s header keys to be returned in lower case.</p><p>Back to&nbsp;Skyscraper. We’re ready to&nbsp;look at the code now. Can you spot the problem?</p><pre><code class="clojure">&#40;let &#91;request-fn &#40;or &#40;:request-fn options&#41; | |
| http/request&#41;&#93; | |
| &#40;http/with-additional-middleware &#91;http/wrap-lower-case-headers&#93; | |
| &#40;request-fn req | |
| success-fn | |
| error-fn&#41;&#41;&#41; | |
| </code></pre><p>I&nbsp;stared at it for several minutes, did some dirty experiments in the REPL, perused the code of clj-http, until it dawned on me.</p><p>See that <code>request-fn</code>? Even though Skyscraper uses <code>http/request</code> by default, you can override it in the options to&nbsp;supply your own way of doing HTTP. (Some of the tests use it to&nbsp;mock calls to&nbsp;a&nbsp;HTTP server.) In this particular case, it was not overridden, though: the usual <code>http/request</code> was used. So things looked good: within the body of <code>http/with-additional-middleware</code>, headers should be lower-cased because <code>request-fn</code> is <code>http/request</code>.</p><p>Or is it?</p><p>Let me show you how <code>with-additional-middleware</code> is implemented. It expands to&nbsp;another macro, <code>with-middleware</code>, which is defined as follows (docstring redacted):</p><pre><code class="clojure">&#40;defmacro with-middleware | |
| &#91;middleware &amp; body&#93; | |
| `&#40;let &#91;m# &#126;middleware&#93; | |
| &#40;binding &#91;&#42;current-middleware&#42; m# | |
| clj-http.client/request &#40;reduce #&#40;%2 %1&#41; | |
| clj-http.core/request | |
| m#&#41;&#93; | |
| &#126;@body&#41;&#41;&#41; | |
| </code></pre><p>That’s right: <code>with-middleware</code> works by dynamically rebinding <code>http/request</code>. Which means the <code>request-fn</code> I&nbsp;was calling is not actually the wrapped version, but the one captured by the outer <code>let</code>, the one that wasn’t rebound, the one without the additional middleware!</p><p>After this light-bulb moment, I&nbsp;moved <code>with-additional-middleware</code> outside of the <code>let</code>:</p><pre><code class="clojure">&#40;http/with-additional-middleware &#91;http/wrap-lower-case-headers&#93; | |
| &#40;let &#91;request-fn &#40;or &#40;:request-fn options&#41; | |
| http/request&#41;&#93; | |
| &#40;request-fn req | |
| success-fn | |
| error-fn&#41;&#41;&#41; | |
| </code></pre><p>And, sure enough, it worked.</p><h2>Part Two: The tests are screaming loud</h2><p>Is it the end of the story? I’m guessing you’re thinking it is. I&nbsp;thought so too. But I&nbsp;wanted to&nbsp;add one last thing: a&nbsp;regression test, so I’d never run into the same problem in the future.</p><p>I&nbsp;whipped up a&nbsp;test in which one ISO-8859-2-encoded page was scraped, and a&nbsp;check for the correct string was made. I&nbsp;ran it against the fixed code. It was green. I&nbsp;ran it against the previous, broken version…</p><p>It was <i>green</i>, too.</p><p>At this point, I&nbsp;knew I&nbsp;had to&nbsp;get to&nbsp;the bottom of this.</p><p>Back to&nbsp;experimenting. After a&nbsp;while, I&nbsp;found out that extracting encoding from a&nbsp;freshly-downloaded page actually worked fine! It only failed when parsing headers fetched from a&nbsp;cache. But the map was the same in both cases! In both cases, the code was effectively doing</p><pre><code class="clojure">&#40;get {&quot;Content-Type&quot; &quot;text/html; charset=ISO-8859-2&quot;} | |
| &quot;content-type&quot;&#41; | |
| </code></pre><p>This lookup <i>shouldn’t</i> succeed: in map lookup, string comparison is case-sensitive. And yet, for freshly-downloaded headers, it <i>did</i> succeed!</p><p>I&nbsp;checked the <code>type</code> of both maps. One of them was a&nbsp;<code>clojure.lang.PersistentHashMap</code>, as expected. The other one was not. It was actually a&nbsp;<code>clj&#95;http.headers.HeaderMap</code>.</p><p>I’ll let the comment of that one speak for itself:</p><blockquote><p> a map implementation that stores both the original (or canonical) key and value for each key/value pair, but performs lookups and other operations using the normalized &ndash; this allows a value to be looked up by many similar keys, and not just the exact precise key it was originally stored with. </p></blockquote><p>And so it turned out that the library authors have actually foreseen the need for looking up headers irrespective of case, and provided a&nbsp;helpful means for that. The whole lowercasing business was not needed, after all!</p><p>I&nbsp;stripped out the <code>with-additional-middleware</code> altogether, added some code elsewhere to&nbsp;ensure that the header map is a&nbsp;<code>HeaderMap</code> regardless of whether it comes from the cache or not, and they lived happily ever after.</p><h2>Epilogue</h2><p>Moral of the story? It’s twofold.</p><ul><li>Dynamic rebinding can be dangerous. Having a&nbsp;public API that is implemented in terms of dynamic rebinding, even more so. I’d prefer if clj-http just allowed the custom middleware to&nbsp;be explicitly specified as an argument, thusly:<pre><code class="clojure">&#40;http/request req | |
| :additional-middleware &#91;http/wrap-lower-case-headers&#93;&#41; | |
| </code></pre></li></ul><ul><li>Know your dependencies. If you have a&nbsp;problem that might be generically addressed by the library you’re using, look deeper. It might be there already.</li></ul><p>Thanks to&nbsp;<a href='https://www.3jane.co.uk'>3Jane</a> for proofreading this article.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2020-01-03:post:word-champions</a:id> | |
| <a:title>Word Champions</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2020/01/03/word-champions/"/> | |
| <a:updated>2020-01-03T00:00:00Z</a:updated> | |
| <a:content type="html"><p>This story begins on August 9, 2017, when a&nbsp;friend messaged me on Facebook: “Hey, I’m going to&nbsp;be on a&nbsp;TV talent show this weekend. They’ll be giving me this kind of problems. Any ideas how to&nbsp;prepare?”</p><p>He attached a&nbsp;link to&nbsp;this video:</p><p><iframe width="100%" height="500" src="https://www.youtube.com/embed/34AcKyYdNBo" frameborder="0" allowfullscreen></iframe></p><p>Now, we’re both avid Scrabble players, so we&nbsp;explored some ideas about extracting helpful data out of the <a href='http://www.pfs.org.pl/english.php'>Official Polish Scrabble Player’s Dictionary</a>. I&nbsp;launched a&nbsp;Clojure REPL and wrote some throwaway code to&nbsp;generate sample training problems for Krzysztof. The code used a&nbsp;brute-force algorithm, so it was dog slow, but it was a&nbsp;start. It was Wednesday.</p><p>I&nbsp;woke up next morning with the problem still in my head. Clearly, I&nbsp;had found myself in a&nbsp;<a href='https://xkcd.com/356/'>nerd sniping</a> situation.</p><p><img src="https://imgs.xkcd.com/comics/nerd_sniping.png"></p><p>There was only one obvious way out—to&nbsp;write a&nbsp;full-blown training app so that Krzysztof could practice as if he were in the studio. The clock was ticking: we&nbsp;had two days left.</p><p>After work, I&nbsp;started a&nbsp;fresh <a href='https://github.com/day8/re-frame/'>re-frame</a> project. (I&nbsp;was a&nbsp;recent re-frame convert those days, so I&nbsp;wanted to&nbsp;see how well it could cope with the task at hand.) Late that night, or rather early next morning, the prototype was ready.</p><p>It had very messy code. It only worked on Chrome. It failed miserably on mobile. It took ages to&nbsp;load. It had native JS dependencies, notably <a href='https://material-ui.com/'>Material-UI</a> and <a href='https://react-dnd.github.io/react-dnd/about'>react-dnd</a>, and for some reason it would not compile with ClojureScript’s advanced optimization turned on; so it weighed in at more than 6 MB, slurping in more than 300 JS files on load.</p><p>But it worked.</p><p>Krzysztof didn’t win his episode against the other contestants, ending up third, but he completed his challenge successfully. It took him 3 minutes and 42 seconds, out of 5 minutes allotted. The episode aired on 24 October.</p><p><iframe width="100%" height="500" src="https://www.youtube.com/embed/7ec6j31nlAk" frameborder="0" allowfullscreen></iframe></p><p>Krzysztof said that the problem he ended up solving on the show was way easier than the ones generated by the app: had they been more difficult, the wow factor might have been higher.</p><p>Several months later, we&nbsp;met at a&nbsp;Scrabble tournament, and I&nbsp;received a&nbsp;present. I&nbsp;wish I&nbsp;had photographed that bottle of wine, so I&nbsp;could show it here, but I&nbsp;hadn’t.</p><p>Meanwhile, the code remained messy and low-priority. But I&nbsp;kept returning to&nbsp;it when I&nbsp;felt like it, fixing up things one at a&nbsp;time. I’ve added difficulty levels, so you can have only one diagram, or three. I’ve made it work on Firefox. I’ve done a&nbsp;major rewrite, restructuring the code in a&nbsp;sane way and removing the JS dependencies other than React. I’ve made advanced compilation work, getting the JS down to&nbsp;400K. I’ve made it work on mobile devices. I’ve written a&nbsp;puzzle generator in C, which ended up several orders of magnitude faster than the prototype Clojure version (it’s still brute-force, but uses some dirty C tricks to&nbsp;speed things up; I&nbsp;hope to&nbsp;rewrite it in Rust someday).</p><p>And now, 2½ years later, I’ve added an English version, with an accompanying set of puzzles (generated from a&nbsp;wordlist taken from <a href='https://github.com/first20hours/google-10000-english'>this repo</a>), for the English-speaking world to&nbsp;enjoy.</p><p><a href='http://danieljanus.pl/wladcyslow/'>Play Word Champions now!</a></p><p>The code is <a href='https://github.com/nathell/wordchampions'>on GitHub</a> if you’d like to&nbsp;check it out or try hacking on it. It’s small, less than 1KLOC in total, so I&nbsp;think it can be a&nbsp;learning tool for re-frame or ClojureScript.</p><p>(This game as featured on the TV shows is called Gridlock. The name “Word Champions” was inspired by the title of Krzysztof’s video on YouTube, literally meaning “Lord of the Words”. There is no pun in the Polish title.)</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2019-10-07:post:web-of-documents</a:id> | |
| <a:title>Web of Documents</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2019/10/07/web-of-documents/"/> | |
| <a:updated>2019-10-07T00:00:00Z</a:updated> | |
| <a:content type="html"><p>In 1960, Ted Nelson envisioned a&nbsp;web of documents.</p><p>It was called <a href='https://en.wikipedia.org/wiki/Project_Xanadu'>Xanadu</a>. It was a&nbsp;grand, holistic vision: of documents that, once published, are available basically forever; of bidirectional links that could glue together not just documents, but parts thereof; of managing copyright and royalties. It was complex. And it never really came to&nbsp;fruition.</p><p>But thirty-one years later, another web of documents took off. A&nbsp;much more modest undertaking than Xanadu, with a&nbsp;simple markup language, simple protocol to&nbsp;retrieve the documents, unidirectional, ever-rotting links, and not much else. The World Wide Web. It was prototyped by one man in a&nbsp;few months. And then its popularity exploded.</p><p>As the WWW spread, it grew features. Soon, it was not enough for the documents to&nbsp;contain just text: support for images was added. People wanted to&nbsp;customize the look of the documents, so HTML gained presentational markup abilities, eventually obsoleted by CSS. It was not enough to&nbsp;be able to&nbsp;view the menu of your local pizza store – people wanted to&nbsp;actually order a&nbsp;pizza: the need for sessions yielded cookies and non-idempotent HTTP methods. And people wanted the pages to&nbsp;be interactive, so they became scriptable.</p><p>All these features were good. They helped the Web meet actual needs. But having them has a&nbsp;significant consequence, one that is seldom realized:</p><p>We&nbsp;don’t have a&nbsp;Web of Documents anymore.</p><p>Let me pause at this point. I’ve been using the word “document” intuitively and vaguely so far, so let’s try to&nbsp;pinpoint it. I&nbsp;don’t have a&nbsp;precise definition in mind, but I’ll share some examples. A&nbsp;book is a&nbsp;document, to&nbsp;me. So is a&nbsp;picture, an illustrated text, a&nbsp;scientific paper, a&nbsp;MP3 song, or a&nbsp;video. By contrast, a&nbsp;page that lets you play Tetris isn’t. The essence of this distinction seems to&nbsp;be that documents have well-defined <i>content</i> that does not change between viewings and does not depend on the state of the outside world. A&nbsp;document is stateless. It exists in and of itself; it is its own microcosm. It may be experienced interactively, but only insofar as it enables the experiencer to&nbsp;focus their attention on the part of their own choosing; the potential state of that interaction is external to&nbsp;the document, not part of itself.</p><p>Obviously, this is not very accurate: there are border cases. For example, does a&nbsp;film DVD with a&nbsp;menu qualify as a&nbsp;document? Or how about a&nbsp;choose-your-own-adventure book? Or a&nbsp;HTML page with links to&nbsp;other pages? On the surface, the latter does provide out-of-microcosm interactivity; but viewed from another angle, it is no different than putting a&nbsp;reference in a&nbsp;book. The browser just makes it very easy to&nbsp;go to&nbsp;a&nbsp;shelf and pick another book.</p><p>The distinction is there, and it’s important. And with it in mind, let me reiterate:</p><p><i>We&nbsp;don’t have a&nbsp;Web of Documents anymore.</i></p><p>These days, the WWW is mostly a&nbsp;<i>Web of Applications</i>. An application is a&nbsp;broader concept: it can display text or images, but also lets you interact not just with itself, but with the world at large. And that’s all well and good, as long as you consciously intend these interactions to&nbsp;happen.</p><p>A&nbsp;document is safe. A&nbsp;book is safe: it will not explode in your hands, it will not magically alter its contents tomorrow, and if it happens to&nbsp;be illegal to&nbsp;possess, it will not call the authorities to&nbsp;denounce you. You can implicitly trust a&nbsp;document by virtue of it being one. An application, not so much.</p><p>I&nbsp;don’t want to&nbsp;name names, but it’s all too easy these days to&nbsp;follow a&nbsp;link to&nbsp;a&nbsp;news site, expecting an article, only to&nbsp;be greeted with “You have read N articles this month, please register to&nbsp;continue”. Definitely an application-y thing to&nbsp;say, not a&nbsp;document-y one. Now, the purveyors of such sites typically have legitimate economic interest in doing so—but once you sign up, they are able to&nbsp;record your actions, link them with your identity and build your shadow profile. This way, we&nbsp;have applications actively <i>masquerading</i> as documents, when in reality they <i>do&nbsp;non-documenty things</i> without telling you.</p><p>Legislation such as the EU Cookie Law and the GDPR (insofar as it requires disclosure of data processing) tries to&nbsp;remedy this. But the more I&nbsp;think about it, the more sense it makes to&nbsp;me to&nbsp;attack the problem closer to&nbsp;its root: to&nbsp;decomplect the notions of a&nbsp;document and an application; to&nbsp;keep the Web of Applications as it is, and to&nbsp;recreate a&nbsp;Web of Documents—either parallel to&nbsp;it, or as its sub-web.</p><p>To&nbsp;do&nbsp;this, we&nbsp;need to&nbsp;take a&nbsp;step back. (Or do&nbsp;a&nbsp;clean start and invent a&nbsp;whole new technology, but this is unlikely to&nbsp;succeed). Fortunately, we&nbsp;don’t have to&nbsp;travel all the way back to&nbsp;1992, when the WWW was still a&nbsp;Web of Documents. (I&nbsp;still remember table-based layouts and spacer gifs, and the very memory makes me shudder). I&nbsp;think we&nbsp;can base the new Web of Documents on ol’ trusty HTTP (or, better, HTTPS), HTML and CSS as we&nbsp;know them today, with just three restraints:</p><ol><li><i>No methods other than GET</i> (and perhaps HEAD). POST, PUT, DELETE and friends just have no place in a&nbsp;world of documents. They are not idempotent; they potentially modify the state of the world, which documents should not be able to&nbsp;do. (I&nbsp;was also thinking “no forms”, but with #1 in place, it seems like an unnecessary refinement. After all, forms that translate to&nbsp;GET requests just facilitate creating URLs: a&nbsp;user could just as well have typed the resulting URL by hand.)</li><li><i>No scripts of any kind.</i> Not JavaScript, not WebAssembly. Not even to&nbsp;enrich a&nbsp;document, such as syntax-highlight the code snippets. This one may seem too stringent, but I&nbsp;think it’s better to&nbsp;err on the safe side, and it’s very easy to&nbsp;enforce.</li><li><i>No cookies.</i> Cookies by themselves aren’t interactive, but having them makes it all too easy to&nbsp;abuse the semantics of HTTP to&nbsp;recreate sessions, and on top of them reinvent the app-wheel and eventually forfeit the Web of Documents again.</li></ol><p>Again, there may be corner cases that may have escaped me. But if a&nbsp;WWW page conforms to&nbsp;these restrictions, I&nbsp;think it may be pretty safe to&nbsp;call it a&nbsp;“document” and make it a&nbsp;part of the Web of Documents.</p><p>How do&nbsp;we&nbsp;achieve this? I&nbsp;don’t know, really. I&nbsp;don’t have a&nbsp;concrete proposal. Perhaps we&nbsp;could have dedicated browsers for the WoD; perhaps we&nbsp;could make existing browsers prominently advertise to&nbsp;the user whether they are browsing a&nbsp;document or an application. On top of all the technical decisions to&nbsp;make, there’ll be significant campaigning and lobbying needed if the idea is ever to&nbsp;take off.</p><p>I&nbsp;don’t dare dream that it ever will. My intent in this article is to&nbsp;provide food for thought. All I&nbsp;ask from you, my reader, is consideration and attention. And if you got this far, chances are I&nbsp;got them. I’m grateful.</p><p>This page is a&nbsp;document. Thank you for reading it.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2019-02-05:post:clj-tvision</a:id> | |
| <a:title>Re-framing text-mode apps</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2019/02/05/clj-tvision/"/> | |
| <a:updated>2019-02-05T00:00:00Z</a:updated> | |
| <a:content type="html"><h2>Intro</h2><blockquote><p> “But, you know, many explorers liked to go to places that are unusual. And, it’s only for the fun of it.” – Richard P. Feynman </p></blockquote><p>A&nbsp;couple of nights ago, I&nbsp;hacked together a&nbsp;small Clojure program.</p><p>All it does is displays a&nbsp;terminal window with a&nbsp;red rectangle in it. You can use your cursor keys to&nbsp;move it around the window, and space bar to&nbsp;change its colour. It’s fun, but it doesn’t sound very useful, does it?</p><p>In this post, I’ll try to&nbsp;convince you that there’s more to&nbsp;this little toy than might at first sight appear. You may want to&nbsp;check out <a href='https://github.com/nathell/clj-tvision'>the repo</a> as you go along.</p><h2>In which an unexpected appearance is made</h2><p>(I’ve always envied <a href='https://technomancy.us'>Phil Hagelberg</a> this kind of headlines.)</p><p>As you might have guessed from this article’s title, clj-tvision (a&nbsp;working name for the program) is a&nbsp;<a href='https://github.com/Day8/re-frame'>re-frame</a> app.</p><p>For those of you who haven’t heard of re-frame, a&nbsp;word of explanation: it’s a&nbsp;ClojureScripty way of writing React apps, with Redux-like management of application state. If you do&nbsp;know re-frame (shameless plug: we&nbsp;at <a href='https://works-hub.com'>WorksHub</a> do, and use it a&nbsp;lot: it powers the site you’re looking at right now!), you’ll instantly find yourself at home. However, a&nbsp;few moments later, a&nbsp;thought might dawn upon you, and you might start to&nbsp;feel a&nbsp;little uneasy…</p><p>Because I’ve mentioned React and ClojureScript, and yet I’d said earlier that we’re talking a&nbsp;text-mode application here. And I’ve mentioned that it’s written in Clojure. It is, in fact, not using React at all, and it has nothing to&nbsp;do&nbsp;whatsoever with ClojureScript, JavaScript, or the browser.</p><p>How is that even possible?</p><p>Here’s the catch: re-frame is implemented in <code>.cljc</code> files. So while it’s mostly used in the ClojureScript frontend, it <i>can</i> be used from Clojure. You may know this if you’re testing your events or subscriptions on the JVM.</p><p>While it’s mostly – if not hitherto exclusively – used for just that, I&nbsp;wanted to&nbsp;explore whether it could be used to&nbsp;manage state in an actual, non-web app. Text-mode is a&nbsp;great playground for this kind of exploration. Rather than picking a&nbsp;GUI toolkit and concern myself with its intricacies, I&nbsp;chose to&nbsp;just put things on a&nbsp;rectangular sheet of text characters.</p><p>(But if you are interested in pursuing a&nbsp;React-ish approach for GUIs, check out what Bodil Stokke’s been doing in <a href='https://github.com/bodil/vgtk'>vgtk</a>.)</p><h2>Living without the DOM</h2><p>The building blocks of a&nbsp;re-frame app are subscriptions, events, and views. While the first two work in Clojureland pretty much the same way they do&nbsp;in the browser (although there are differences, of which more anon), views are a&nbsp;different beast.</p><p><a href='https://github.com/Day8/re-frame/blob/master/docs/SubscriptionFlow.md'>re-frame’s documentation</a> says that views are “data in, Hiccup out. Hiccup is ClojureScript data structures which represent DOM.” But outside of the browser realm, there’s no DOM. So let’s rephrase that more generally: re-frame views should produce <i>data structures which declaratively describe the component’s appearance to&nbsp;the user</i>. In web apps, those structures correspond to&nbsp;the DOM. What they will look like outside is up to&nbsp;us. We’ll be growing our own DOM-like model, piecemeal, as needs arise.</p><p>For clj-tvision, I’ve opted for a&nbsp;very simple thing. Let’s start with a&nbsp;concrete example. Here’s a&nbsp;view:</p><pre><code class="clojure">&#40;defn view &#91;&#93; | |
| &#91;{:type :rectangle, :x1 10, :y1 5, :x2 20, :y2 10, :color :red}&#93;&#41; | |
| </code></pre><p>Unlike in the DOM, in this model the UI state isn’t a&nbsp;tree. It’s a&nbsp;flat sequence of maps that each represent individual “primitive elements”. We&nbsp;could come up with a&nbsp;fancy buzzword-compliant name and call it Component List Model, or CLiM for short, in homage to&nbsp;<a href='https://en.wikipedia.org/wiki/Common_Lisp_Interface_Manager'>the venerable GUI toolkit</a>.</p><p>Like normal re-frame views, CLiM views can include subviews. An example follows:</p><pre><code class="clojure">&#40;defn square &#91;left top size color&#93; | |
| &#91;{:type :rectangle, | |
| :x1 left, | |
| :y1 top, | |
| :x2 &#40;+ left size -1&#41;, | |
| :y2 &#40;+ top size -1&#41;, | |
| :color color}&#93;&#41; | |
| &#40;defn view &#91;&#93; | |
| &#91;&#91;square 1 1 5 :red&#93; | |
| &#91;square 9 9 5 :blue&#93;&#93;&#41; | |
| </code></pre><p>How to&nbsp;render a&nbsp;view? Simple. First, flatten the list, performing funcalls on subviews so that you get a&nbsp;sequence containing only primitives. Then, draw each of them in order. (If there is an overlap, the trailers will obscure the leaders. Almost biblical.)</p><p>I’ve defined a&nbsp;multimethod, <code>render-primitive</code>, dispatching on <code>:type</code>. Its methods draw the corresponding primitive to&nbsp;a&nbsp;Lanterna screen.</p><p>Oh, didn’t I&nbsp;mention <a href='https://github.com/mabe02/lanterna'>Lanterna</a>? It’s a&nbsp;Java library for terminals. Either real ones or emulated in Swing (easier to&nbsp;work with when you’re in a&nbsp;CIDER REPL). Plus, it sports virtual screens which can be blitted to&nbsp;a&nbsp;real terminal. This gives us a&nbsp;rough poor man’s equivalent of React’s VDOM. And it has a&nbsp;<a href='https://github.com/AvramRobert/clojure-lanterna'>Clojure wrapper</a>!</p><h2>Events at eventide</h2><p>So now we&nbsp;know how to&nbsp;draw our UI. But an app isn’t made up of just drawing. It has a&nbsp;main loop: it listens to&nbsp;events, which cause the app state to&nbsp;change and the corresponding components to&nbsp;redraw.</p><p>re-frame does provide an event mechanism, but it doesn’t <i>define</i> any events per se. So we&nbsp;need to&nbsp;ask ourselves: who calls <i>dispatch</i>? How do&nbsp;events originate? How to&nbsp;write the main loop?</p><p>clj-tvision is a&nbsp;proof-of-concept, so it doesn’t concern itself with mouse support. There’s only one way a&nbsp;user can interact with the app: via the keyboard. So keystrokes will be the only “source events”, as it were, for the app; and so writing the event loop should be simple. Sketching pseudocode:</p><pre><code class="clojure">&#40;loop &#91;&#93; | |
| &#40;render-app&#41; | |
| &#40;let &#91;keystroke &#40;wait-for-key&#41;&#93; ;; blocking! | |
| &#40;dispatch &#91;:key-pressed keystroke&#93;&#41; | |
| &#40;recur&#41;&#41;&#41; | |
| </code></pre><p>Simple as that, should work, right?</p><p>Wrong.</p><p>If you actually try that, it’ll <i>somewhat</i> work. Hit right arrow to&nbsp;move the rectangle, nothing happens! Hit right arrow again, it moves. Hit left, it moves right. Hit right, it moves left. Not what you want.</p><p>You see, there’s a&nbsp;complication stemming from the fact that re-frame’s events are asynchronous by default. (Hence the <code>dispatch</code> vs. <code>dispatch-sync</code> dichotomy.) They don’t get dispatched immediately; rather, re-frame places them on a&nbsp;queue and processes them asynchronously, so that they don’t hog the browser. The Clojure version of re-frame handles that using a&nbsp;single-threaded executor with a&nbsp;dedicated thread.</p><p>We&nbsp;<i>almost</i> could use <code>dispatch-sync</code> everywhere, but for re-frame that’s a&nbsp;no-no: once within a&nbsp;<code>dispatch-sync</code> handler, you cannot dispatch other events. If you try anyway, re-frame will detect it and politely point its dragon-scaly head at you, explaining it doesn’t like it. (It is a&nbsp;benevolent dragon, you know.)</p><p>So we&nbsp;need to&nbsp;hook into that “next-tick” machinery of re-frame’s somehow. There are probably better ways of doing this, but I&nbsp;opted to&nbsp;blatantly redefine <code>re-frame.interop/next-tick</code> to&nbsp;tell the main loop: “hey, events have been handled and we&nbsp;have a&nbsp;new state, dispatch an event so we&nbsp;can redraw.” This is one of the rare cases where monkey-patching third-party code with <code>alter-var-root</code> saves you the hassle of forking that entire codebase.</p><p>So now we&nbsp;have <i>two</i> sources of events: keystrokes, and <code>next-tick</code>. To&nbsp;multiplex them, I’ve whipped up a&nbsp;channel with core.async. Feels hacky, but allows to&nbsp;add mouse support in the future. Or time-based events that will be fired periodically every so often.</p><p>For completeness, I&nbsp;should also add that Clojure-side re-frame doesn’t have the luxury of having reactive atoms provided by Reagent. Its ratoms are ordinary Clojure atoms. Unlike in ClojureScript, any time the app state changes, <i>every</i> subscription in the signal graph will be recomputed. It may well be possible to&nbsp;port Reagent’s ratoms to&nbsp;Clojure, but it is a&nbsp;far more advanced exercise. For simple apps, what re-frame provides on its own might just be enough.</p><p>And with that final bit, we&nbsp;can swipe all that hackitude under the carpet… or, should I&nbsp;say, tuck it into an internal ns that hopefully no-one will ever look into. And we’re left with shiny, declarative, re-framey, beautiful UI code on the surface. <a href='https://github.com/nathell/clj-tvision/blob/master/src/tvision/core.clj'>Just look</a>.</p><h2>Closing thoughts</h2><blockquote><p> “Within C++, there is a much smaller and cleaner language struggling to get out.” – Bjarne Stroustrup </p></blockquote><p>If you’ve ever encountered legacy C++ code, this will ring true. Come to&nbsp;think of it, Stroustrup’s words are true of every system that has grown organically over its lifetime, with features being added to&nbsp;it but hardly ever removed.</p><p>And modern webapps may well be the epitome of that kind of system. We&nbsp;now have desktop apps that are fully self-contained on a&nbsp;single machine, yet use an overwhelmingly complex and vast machinery grown out of a&nbsp;simple system originally devised to&nbsp;<a href='http://info.cern.ch/hypertext/WWW/TheProject.html'>view static documents over the Internet</a>.</p><p>For all that complexity, we&nbsp;continue to&nbsp;use it. Partly owing to&nbsp;its ubiquity, partly for convenience. In my experience, the abstractions provided by re-frame allow you to&nbsp;wrap your head around large apps and reason about them much more easily than, say, object-oriented approaches. It just feels right. Conversely, writing an app in, say, GTK+ would now feel like a&nbsp;setback by some twenty years.</p><p>So this toy, this movable rectangle on a&nbsp;black screen, is not so much an app as it is a&nbsp;philosophical exercise. It is what my typing fingers produced while I&nbsp;pondered, weak and weary: “can we&nbsp;throw away most of that cruft, while still enjoying the abstractions that make life so much easier?”</p><p>Can we?</p><p>This post was originally published on <a href='https://functional.works-hub.com/learn/re-framing-text-mode-apps-fd5cf'>Functional Works</a>.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2014-09-13:post:happy-programmers-day</a:id> | |
| <a:title>Happy Programmers’ Day!</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2014/09/13/happy-programmers-day/"/> | |
| <a:updated>2014-09-13T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Happy <a href='https://en.wikipedia.org/wiki/Programmers'_Day'>Programmers’ Day</a>, everyone!</p><p>A&nbsp;feast isn’t a&nbsp;feast, though, until it has a&nbsp;proper way of celebrating it. The <a href='https://en.wikipedia.org/wiki/Pi_Day'>Pi Day</a>, for instance, has one: you eat a&nbsp;pie (preferably exactly at 1:59:26.535am), but I&nbsp;haven’t heard of any way of celebrating the Programmers’ Day, so I&nbsp;had to&nbsp;invent one. An obvious way would be to&nbsp;write a&nbsp;program, preferably a&nbsp;non-trivial one, but that requires time and dedication, which not everyone is able to&nbsp;readily spare.</p><p>So here’s my idea: on Programmers’ Day, dust off a&nbsp;program that you wrote some time ago — something that is just lying around in some far corner of your hard disk, that you haven’t looked at in years, but that you had fun writing — and put it on <a href='https://github.com/'>GitHub</a> for all the world to&nbsp;see, to&nbsp;share the joy of programming.</p><p>Let me initialize the new tradition by doing this myself. Here’s <a href='https://github.com/nathell/haze'>HAZE</a>, the Haskellish Abominable Z-machine Emulator. It was my final assignment for a&nbsp;course in Advanced Functional Programming, in my fourth year at the Uni, way back in 2004. It is an emulator for an ancient kind of virtual machine, the <a href='https://en.wikipedia.org/wiki/Z-machine'>Z-machine</a>, written from scratch in Haskell. It allows you to&nbsp;play text adventure games, such as <a href='https://en.wikipedia.org/wiki/Zork'>Zork</a>, much in the vein of <a href='https://davidgriffith.gitlab.io/frotz/'>Frotz</a>. It’s not very complete, and supports versions of the Z-machine up to&nbsp;3 only, so newer games won’t run on it as it stands, but Zork is playable.</p><p>It probably won’t even compile in modern Haskell systems: it was originally written for GHC version 6.2.1, and extensively uses the FiniteMap data type, which was obsoleted shortly after and is no longer found in modern systems. I&nbsp;should have Linux and Windows binaries lying around (yes, I&nbsp;had compiled it under Windows, using MinGW/PDCurses); I’ll put them on GitHub once I&nbsp;find them.</p><p>My mind now wanders ten years back in time, to&nbsp;the days when I&nbsp;was writing it. It took me about three summer weeks to&nbsp;write HAZE from scratch, most of that time on a&nbsp;slow laptop where it took quite a&nbsp;lot of seconds to&nbsp;get GHC to&nbsp;compile even a&nbsp;simple thing. I&nbsp;would do&nbsp;some of it differently if I&nbsp;were doing it now — for one, the state of a&nbsp;<code>ZMachine</code> is a&nbsp;central datatype to&nbsp;HAZE, and you’ll find a&nbsp;lot of functions that take and return ZMachines, so a&nbsp;state monad is an obvious choice; I&nbsp;didn’t understand monads well enough back then. But I&nbsp;still remember how I&nbsp;had the framework in place already and I&nbsp;was adding implementations of Z-code opcodes, one by one, to&nbsp;<code>ZMachine/ZCode/Impl.hs</code>, recompiling, rerunning, getting messages about unimplemented opcodes, when all of a&nbsp;sudden I&nbsp;got the familiar message about a&nbsp;white house and a&nbsp;small mailbox. Freude!</p><p>I&nbsp;hope you enjoy looking at it at least half as much as I&nbsp;had enjoyed writing it.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2014-05-20:post:you-already-use-lisp-syntax</a:id> | |
| <a:title>You already use Lisp syntax</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2014/05/20/you-already-use-lisp-syntax/"/> | |
| <a:updated>2014-05-20T00:00:00Z</a:updated> | |
| <a:content type="html"><p><strong>Unix Developer:</strong> I’m not going to&nbsp;touch Lisp. It’s horrible!</p><p><strong>Me:</strong> Why so?</p><p><strong>UD:</strong> The syntax! This illegible prefix-RPN syntax that nobody else uses. And just look at all these parens!</p><p><strong>Me:</strong> Well, many people find it perfectly legible, although most agree that it takes some time to&nbsp;get accustomed to. But I&nbsp;think you’re mistaken. Lots of people are using Lisp syntax on a&nbsp;daily basis…</p><p><strong>UD:</strong> I&nbsp;happen to&nbsp;know no one doing this.</p><p><strong>Me:</strong> …without actually realizing this. In fact, I&nbsp;think <i>you</i> yourself are using it.</p><p><strong>UD:</strong> Wait, <i>what</i>?!</p><p><strong>Me:</strong> And the particular variant of Lisp syntax you’re using is called Bourne shell.</p><p><strong>UD:</strong> Now I&nbsp;don’t understand. What on earth does the shell have to&nbsp;do&nbsp;with Lisp?</p><p><strong>Me:</strong> Just look: in the shell, you put the name of the program first, followed by the arguments, separated by spaces. In Lisp it’s exactly the same, except that you put an opening paren at the beginning and a&nbsp;closing paren at the end.</p><p>Shell: <code>run-something arg1 arg2 arg3</code></p><p>Lisp: <code>&#40;run-something arg1 arg2 arg3&#41;</code></p><p><strong>UD:</strong> I&nbsp;still don’t get the analogy.</p><p><strong>Me:</strong> Then you need a&nbsp;mechanism for expression composition — putting the output of one expression as an input to&nbsp;another. In Lisp, you just nest the lists. And in the shell?</p><p><strong>UD:</strong> Backticks.</p><p><strong>Me:</strong> That’s right. Or <code>$&#40;&#41;</code>, which has the advantage of being more easily nestable. Let’s try arithmetic. How do&nbsp;you do&nbsp;arithmetic in the shell?</p><p><strong>UD:</strong> <code>expr</code>. Or the Bash builtin <code>let</code>. For example,</p><pre><code class="bash">$ let x='2&#42;&#40;&#40;10+4&#41;/7&#41;'; echo $x | |
| 4 | |
| </code></pre><p><strong>Me:</strong> Now wouldn’t it be in line with the spirit of Unix — to&nbsp;have programs do&nbsp;just one thing — if we&nbsp;had one program to&nbsp;do&nbsp;addition, and another to&nbsp;do&nbsp;subtraction, and yet another to&nbsp;do&nbsp;multiplication and division?</p><p>It’s trivial to&nbsp;write it in C:</p><pre><code class="c">#include &lt;stdio.h&gt; | |
| #include &lt;stdlib.h&gt; | |
| #include &lt;string.h&gt; | |
| int main&#40;int argc, char &#42;&#42;argv&#41; { | |
| int mode = -1, cnt = argc - 1, val, i; | |
| char &#42;&#42;args = argv + 1; | |
| switch &#40;argv&#91;0&#93;&#91;strlen&#40;argv&#91;0&#93;&#41; - 1&#93;&#41; { | |
| case '+': mode = 0; break; | |
| case '-': mode = 1; break; | |
| case 'x': mode = 2; break; | |
| case 'd': mode = 3; break; | |
| } | |
| if &#40;mode == -1&#41; { | |
| fprintf&#40;stderr, &quot;invalid math operation\n&quot;&#41;; | |
| return 1; | |
| } | |
| if &#40;&#40;mode == 1 || mode == 3&#41; &amp;&amp; !cnt&#41; { | |
| fprintf&#40;stderr, &quot;%s requires at least one arg\n&quot;, argv&#91;0&#93;&#41;; | |
| return 1; | |
| } | |
| switch &#40;mode&#41; { | |
| case 0: val = 0; break; | |
| case 2: val = 1; break; | |
| default: val = atoi&#40;&#42;args++&#41;; cnt--; break; | |
| } | |
| while &#40;cnt--&#41; { | |
| switch &#40;mode&#41; { | |
| case 0: val += atoi&#40;&#42;args++&#41;; break; | |
| case 1: val -= atoi&#40;&#42;args++&#41;; break; | |
| case 2: val &#42;= atoi&#40;&#42;args++&#41;; break; | |
| case 3: val /= atoi&#40;&#42;args++&#41;; break; | |
| } | |
| } | |
| printf&#40;&quot;%d\n&quot;, val&#41;; | |
| return 0; | |
| } | |
| </code></pre><p>This dispatches on the last character of its name, so it can be symlinked to&nbsp;<code>+</code>, <code>-</code>, <code>x</code> and <code>d</code> (I&nbsp;picked unusual names for multiplication and division to&nbsp;make them legal and avoid escaping).</p><p>Now behold:</p><pre><code class="bash">$ x 2 $&#40;d $&#40;+ 10 4&#41; 7&#41; | |
| 4 | |
| </code></pre><p><strong>UD:</strong> Wow, this sure looks a&nbsp;lot like Lisp!</p><p><strong>Me:</strong> And yet it’s the shell. Our two basic rules — program-name-first and <code>$&#40;&#41;</code>-for-composition — allowed us to&nbsp;explicitly specify the order of evaluation, so there was no need to&nbsp;do&nbsp;any fancy parsing beyond what the shell already provides.</p><p><strong>UD:</strong> So is the shell a&nbsp;Lisp?</p><p><strong>Me:</strong> Not really. The shell is <a href='http://blog.codinghorror.com/new-programming-jargon/'>stringly typed</a>: a&nbsp;program takes textual parameters and produces textual output. To&nbsp;qualify as a&nbsp;Lisp, it would have to&nbsp;have a&nbsp;composite type: a&nbsp;list or a&nbsp;cons cell to&nbsp;build lists on top of. Then, you’d be able to&nbsp;represent code as this data structure, and write programs to&nbsp;transform code to&nbsp;other code.</p><p>But the Tao of Lisp lingers in the shell syntax.</p><p><hr></p><p>I&nbsp;know I’ve glossed over many details here, like the shell syntax for redirection, globbing, subprocesses, the fact that programs have standard input in addition to&nbsp;command-line arguments, pipes, etc. — all these make the analogy rather weak. But I&nbsp;think it’s an interesting way to&nbsp;teach Lisp syntax to&nbsp;people.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2014-04-06:post:dos-debugging-quirk</a:id> | |
| <a:title>DOS debugging quirk</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2014/04/06/dos-debugging-quirk/"/> | |
| <a:updated>2014-04-06T00:00:00Z</a:updated> | |
| <a:content type="html"><p>While hacking on Lithium, I’ve noticed an interesting thing. Here’s a&nbsp;sample DOS program in assembly (TASM syntax):</p><pre><code class="asm">.model tiny | |
| .code | |
| org 100h | |
| N equ 2 | |
| start: | |
| mov bp,sp | |
| mov ax,100 | |
| mov &#91;bp-N&#93;,ax | |
| mov cx,&#91;bp-N&#93; | |
| cmp cx,ax | |
| jne wrong | |
| mov dx,offset msg | |
| jmp disp | |
| wrong: | |
| mov dx,offset msg2 | |
| disp: | |
| mov ah,9 | |
| int 21h | |
| mov ax,4c00h | |
| int 21h | |
| msg db &quot;ok$&quot; | |
| msg2 db &quot;wrong$&quot; | |
| end start | |
| </code></pre><p>If you assemble, link and then execute it normally, typing <code>prog</code> in the DOS command line, it will output the string “ok”. But if you trace through the program in a&nbsp;debugger instead, it will say “wrong”! What’s wrong?</p><p>The problem is in lines 10-11 (instructions 3-4). Here’s what happens when you trace through this program in DOS 6.22’s <code>DEBUG.EXE</code>:</p><p><img src="/img/blog/debug.png"></p><p>Note how in instruction 3 (actually displayed as the second above) we&nbsp;set the word <code>SS:0xFFFC</code> to&nbsp;<code>100</code>. When about to&nbsp;execute the following instruction, we&nbsp;would expect that word to&nbsp;continue to&nbsp;hold the value <code>100</code>, because nothing which could have changed that value has happened in between. Instead, the debugger still reports it as <code>0x0D8A</code>, as if instruction 3 had not been executed at all — and, interestingly, after actually executing this instruction, <code>CX</code> gets yet another value of <code>0x7302</code>!</p><p>Normally, thinking of DOS <code>.COM</code> programs, you assume a&nbsp;64KB-long chunk of memory that the program has all to&nbsp;itself: the code starts at <code>0x100</code>, the stack grows from <code>0xFFFE</code> downwards (at any given time, the region from <code>SP</code> to&nbsp;<code>0xFFFE</code> contains data currently on the stack), and all memory in between is free for the program to&nbsp;use however it deems fit. It turns out that, when debugging, it is not the case: the debuggers need to&nbsp;manipulate the region just underneath the program’s stack in order to&nbsp;handle the tracing/breakpoint interrupt traps.</p><p>I’ve verified that both DOS’s DEBUG and Borland’s Turbo Debugger 5 do&nbsp;this. The unsafe-to-touch amount of space below SP that they need, however, varies. Manipulating the N constant in the original program, I’ve determined that DEBUG only needs 8 bytes below SP, whereas for TD it is a&nbsp;whopping 18 bytes.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2014-04-02:post:2048</a:id> | |
| <a:title>2048: A close look at the source</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2014/04/02/2048/"/> | |
| <a:updated>2014-04-02T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Dust has now mostly settled down on <a href='https://gabrielecirulli.github.io/2048/'>2048</a>. Yet, in all the deluge of variants and clones that has swept through <a href='https://news.ycombinator.com/'>Hacker News</a>, little has been written about the experience of modifying the game. As I&nbsp;too have jumped on the 2048-modding bandwagon, it’s time to&nbsp;fill that gap, because, as we&nbsp;shall see, the code more than deserves a&nbsp;close look.</p><p>I’ll start with briefly describing my variant. It’s called <a href='http://danieljanus.pl/wosg'>“words oh so great”</a> (a&nbsp;rather miserable attempt at a&nbsp;pun on “two-oh-four-eight”) and is a&nbsp;consequence of a&nbsp;thought I&nbsp;had, being an avid Scrabble player, after seeing the <a href='http://joppi.github.io/2048-3D/'>3D</a> and <a href='http://huonw.github.io/2048-4D/'>4D</a> versions: “what if we&nbsp;mashed 2048 and Scrabble together?” The answer just lended itself automatically.</p><p>Letters instead of number tiles, that was obvious. And you use them to&nbsp;form words. It is unclear how merging tiles should work: merging two identical tiles, as in the original, just wouldn’t make sense here, so drop the concept of merging and make the tiles disappear instead when you form a&nbsp;word. In Scrabble, the minimum length of a&nbsp;word is two, but allowing two-letter words here would mean too many words formed accidentally, so make it at least three. And 16 squares sounds like too tight a&nbsp;space, so increase it to&nbsp;5x5. And there you have the modified rules.</p><p>I&nbsp;<a href='https://github.com/nathell/wosg'>cloned</a> the Git repo, downloaded an English word list (<a href='http://dreamsteep.com/projects/the-english-open-word-list.html'>EOWL</a>), and set out to&nbsp;work. It took me just over three hours from the initial idea to&nbsp;putting the modified version online and submitting a&nbsp;link to&nbsp;HN. I&nbsp;think three hours is not bad, considering that I’ve significantly changed the game mechanics. And, in my opinion, this is a&nbsp;testimony to&nbsp;the quality of Gabriele Cirulli’s code.</p><p>The code follows the MVC pattern, despite not relying on any frameworks or libraries. The model is comprised of the <code>Tile</code> and <code>Grid</code> classes, laying out the universe for the game as well as some basic rules governing it, and the <code>GameManager</code> that implements the game mechanics: how tiles move around, when they can merge together, when the game ends, and so on. It also uses a&nbsp;helper class called <code>LocalStorageManager</code> to&nbsp;keep the score and save it in the browser’s local storage.</p><p>The view part is called an “actuator” in 2048 parlance. The <code>HTMLActuator</code> takes the game state and updates the DOM tree accordingly. It also uses a&nbsp;micro-framework for animations. The controller takes the form of a&nbsp;<code>KeyboardInputManager</code>, whose job is to&nbsp;receive keyboard events and translate them to&nbsp;changes of the model.</p><p>The <code>GameManager</code> also contains some code to&nbsp;tie it all together — not really a&nbsp;part of the model as in MVC. Despite this slight inconsistency, the separation of concerns is very neatly executed in 2048’s code; I&nbsp;would even go so far as to&nbsp;say that it could be used as a&nbsp;demonstration in teaching MVC to&nbsp;people.</p><p>The only gripe I&nbsp;had with the code is that it violates the DRY principle in several places. Specifically, to&nbsp;change the board size to&nbsp;5x5, I&nbsp;had to&nbsp;modify as many as three places: the HTML (it contains the initial definition for the DOM, including 16 empty divs making up the grid, which is unfortunate — I’d change it to&nbsp;set up the DOM at runtime during initialization); the model (instantiation of <code>GameManager</code>); and the <code>.scss</code> file from which the CSS is generated.</p><p>While on this topic, let me add that 2048’s usage of SASS is a&nbsp;prime example of its capabilities. It is very instructive to&nbsp;see how the sizing and positioning of the grid, and also styling for the tiles down to&nbsp;the glow, is done programmatically. I&nbsp;was aware of the existence of SASS before, but never got around to&nbsp;explore it. Now, I’m sold on it.</p><p>To&nbsp;sum up: 2048 rocks. And it’s fun to&nbsp;modify. Go try it.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2013-05-26:post:lithium-revisited</a:id> | |
| <a:title>Lithium revisited: A 16-bit kernel (well, sort of) written in Clojure (well, sort of)</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2013/05/26/lithium-revisited/"/> | |
| <a:updated>2013-05-26T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Remember <a href='http://blog.danieljanus.pl/blog/2012/05/14/lithium/'>Lithium</a>? The x86 assembler written in Clojure, and a&nbsp;simple stripes effect written in it? Well, here’s another take on that effect:</p><p><img src="/img/blog/stripes2.png"></p><p>And here is the source code:</p><pre><code class="clojure">&#40;do &#40;init-graph&#41; | |
| &#40;loop &#91;x 0 y 0&#93; | |
| &#40;put-pixel x y &#40;let &#91;z &#40;mod &#40;+ &#40;- 319 x&#41; y&#41; 32&#41;&#93; | |
| &#40;if &#40;&lt; z 16&#41; &#40;+ 16 z&#41; &#40;+ 16 &#40;- 31 z&#41;&#41;&#41;&#41;&#41; | |
| &#40;if &#40;= y 200&#41; | |
| nil | |
| &#40;if &#40;= x 319&#41; | |
| &#40;recur 0 &#40;inc y&#41;&#41; | |
| &#40;recur &#40;inc x&#41; y&#41;&#41;&#41;&#41;&#41; | |
| </code></pre><p>I’ve implemented this several months ago, pushed it to&nbsp;Github and development has pretty much stalled since then. And after seeing <a href='https://news.ycombinator.com/item?id=5771276'>this recent post</a> on HN today, I’ve decided to&nbsp;give Lithium a&nbsp;little more publicity, in the hope that it will provide a&nbsp;boost of motivation to&nbsp;me. Because what we&nbsp;have here is pretty similar to&nbsp;Rustboot: it’s a&nbsp;16-bit kernel written in Clojure.</p><p>Well, sort of.</p><p>After writing a&nbsp;basic assembler capable of building bare binaries of simple x86 real-mode programs, I’ve decided to&nbsp;make it a&nbsp;building block of a&nbsp;larger entity. So I’ve embarked on a&nbsp;project to&nbsp;implement a&nbsp;compiler for a&nbsp;toy Lisp-like language following the paper <a href='http://scheme2006.cs.uchicago.edu/11-ghuloum.pdf'>“An Incremental Approach to&nbsp;Compiler Construction”</a>, doing it in Clojure and making the implemented language similar to&nbsp;Clojure rather than to&nbsp;Scheme.</p><p>(Whether it actually can be called Clojure is debatable. It’s unclear what the definition of Clojure the language is. Is running on JVM a&nbsp;part of what makes Clojure Clojure? Or running on any host platform? Is ClojureScript Clojure? What about ClojureCLR, or clojure-py?)</p><p>So far I’ve only gotten to&nbsp;step 7 of 24 or so, but that’s already enough to&nbsp;have a&nbsp;working <code>loop/recur</code> implementation, and it was trivial to&nbsp;throw in some graphical mode 13h primitives to&nbsp;be able to&nbsp;implement this effect.</p><p>By default I’m running Lithium programs as DOS .COM binaries under DOSBox, but technically, the code doesn’t depend on DOS in any way (it doesn’t ever invoke interrupt 21h) and so it can be combined with a&nbsp;simple bootloader into a&nbsp;kernel runnable on the bare metal.</p><p>The obligatory HOWTO on reproducing the effect: install DOSBox and Leiningen, checkout <a href=''>the code</a>, launch a&nbsp;REPL with <code>lein repl</code>, execute the following forms, and enjoy the slowness with which individual pixels are painted:</p><pre><code class="clojure">&#40;require 'lithium.compiler&#41; | |
| &#40;in-ns 'lithium.compiler&#41; | |
| &#40;run! &#40;compile-program &quot;/path/to/lithium/examples/stripes-grey.clj&quot;&#41;&#41; | |
| </code></pre></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2012-09-13:post:my-top-three-ios-apps-for-mapping</a:id> | |
| <a:title>My top three iOS apps for mapping</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2012/09/13/my-top-three-ios-apps-for-mapping/"/> | |
| <a:updated>2012-09-13T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Living in London means that I&nbsp;now have a&nbsp;whole lot of new area to&nbsp;explore by cycling or walking. I&nbsp;try to&nbsp;take every opportunity to&nbsp;spend a&nbsp;free day or weekend out. One of the most important things when on the move is knowing where you are, where to&nbsp;go, and how to&nbsp;get there — and for that, you need a&nbsp;map. As I&nbsp;soon learned, the maps to&nbsp;use in the UK are the Ordnance Survey ones (either the Landranger/Explorer series, or maps by another publisher, such as AA, based on OS data). However, the Landranger series encompasses over 200 1:50000 maps, standing at some £8 each, and when that level of detail is not enough, there are more than 400 Explorer maps on top of that. Not only does this get pricey after a&nbsp;while, but also the sheer volume of map juggling quickly becomes impractical when you cycle a&nbsp;lot outside of town.</p><p>So I’ve turned to&nbsp;my old trusty iPhone 3GS as a&nbsp;mapping device instead, and set out to&nbsp;complete a&nbsp;set of mapping apps that do&nbsp;the job for me. In this post, I’d like to&nbsp;share my list.</p><p>I&nbsp;briefly thought of directly using OS maps on the iPhone via the <a href='http://itunes.apple.com/gb/app/outdoors-gb-national-parks/id336150457?mt=8'>Outdoors GPS GB app</a>; it does meet my requirement of being accessible off-network, but the pricing of individual maps is on par with the paper version, so I&nbsp;ruled it out.</p><p>Instead, I&nbsp;am using this trio now:</p><ol><li>The official <a href='http://itunes.apple.com/gb/app/the-complete-national-cycle/id436521445?mt=8&amp;ls=1'>National Cycle Network</a> app by Sustrans. Beside being free, it has an advantage of detailing every numbered national cycle route, as well as most local routes (that often predate NCN or are not yet integrated into the network). At high detail, the data seem to&nbsp;be OS-sourced, which is good.<br><br> It downloads maps from the Internet on demand, but you can also save a&nbsp;map portion for future use. The app asks you how much detail you want, tells you how large the download will be, then proceeds to&nbsp;get the data. The nuisance here is that you can only download 40 MB in one go, which corresponds to&nbsp;an area stretching for approximately 50-60 km at 1:50000 (and correspondingly smaller at 1:25000), so it takes a&nbsp;lot of tapping and downloading if you’re planning a&nbsp;longer trip.<br><br> The other downsides are that the app is a&nbsp;little shaky at times, and GPS positioning sometimes displays your position somewhat misplaced. I&nbsp;mitigate this by using this app in combination with the next one…<br><br></li><li>…which is <a href='http://www.mapswithme.com/'>MapsWithMe</a>. The tagline “Offline Mobile Maps” nails it down: it’s just maps, easily downloadable, covering the entire world, and nothing else. This really does one thing well. The map data source is OpenStreetMap, so all the maps are available for free as well; one ‘Download’ tap and you’ve got the whole country covered, once and for all. It also displays GPS position much more reliably than NCN. On the other hand, it can’t offer quite the same level of detail as NCN, and doesn’t know anything about cycle routes, but it’s still highly convenient.<br><br> My typical flow when cycling in the UK is: check my position with MapsWithMe, then optionally switch to&nbsp;NCN, locate the same position on the map by hand and see where the route goes. I’ve also done one continental three-day trip, from Dunkirk in France to&nbsp;Hoek van Holland in the Netherlands, using just MapsWithMe to&nbsp;navigate, and it worked out very well.<br><br></li><li>Unlike the other two, the last app I&nbsp;want to&nbsp;point out, <a href='http://www.codeartisans.co.uk/index.html'>GPS2OS</a>, is paid. And it’s more than worth its meager price, despite being next to&nbsp;useless when cycling. But when hiking, especially in remote mountainous areas, it can literally be a&nbsp;lifesaver. Here’s the catch: my basic navigation tools in harsh conditions are a&nbsp;compass and a&nbsp;plain ol’ paper map, and the iPhone is treated only as a&nbsp;supplementary aid (you never know when the battery goes out). However, instead of indicating the latitude and longitude in degrees/minutes/seconds, OS maps use <a href='http://en.wikipedia.org/wiki/Ordnance_Survey_National_Grid'>their own grid</a>. So you cannot use the default Compass app, which tells you your position in degrees, directly with them, and you need a&nbsp;tool just like this one to&nbsp;do&nbsp;the coordinate translation. Works very well; it helped me find my way in dense mist down from the summit of Ben Macdui during my recent holiday in Scotland.</li></ol><p>One final tip: when you want to&nbsp;conserve battery as much as possible, airplane mode is a&nbsp;real saver. However, GPS doesn’t seem to&nbsp;work when airplane mode is on. So the next best thing is to&nbsp;remove the SIM card (you can then reinsert it, just don’t enter the PIN), so that the phone doesn’t keep trying to&nbsp;connect to&nbsp;cellular networks. And keep it warm in a&nbsp;pocket beside your body: cold devices discharge much faster.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2012-05-14:post:lithium</a:id> | |
| <a:title>Lithium: an x86 assembler for Clojure</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2012/05/14/lithium/"/> | |
| <a:updated>2012-05-14T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Ah, the golden days of childhood’s hackage. Don’t you have fond memories of them?</p><p>I&nbsp;got my first PC when I&nbsp;was 10. It was a&nbsp;486DX2/66 with 4 megs of RAM and a&nbsp;170 meg HDD; it ran DOS and had lots of things installed on it, notably Turbo Pascal 6. I&nbsp;hacked a&nbsp;lot in it. These were pre-internet days when knowledge was hard to&nbsp;come by, especially for someone living in a&nbsp;<a href='http://en.wikipedia.org/wiki/W%C4%85chock'>small town in Poland</a>; my main sources were the software I&nbsp;had (TP’s online help was of excellent quality), a&nbsp;couple of books, and a&nbsp;<a href='http://www.cpcwiki.eu/index.php/Bajtek'>popular computing magazine</a> that published articles on programming. From the latter, I&nbsp;learned how to&nbsp;program the VGA: how to&nbsp;enter mode 13h, draw pixels on screen, wait for vertical retrace, manipulate the palette and how to&nbsp;combine these things into neat effects. One of the very first thing I&nbsp;discovered was when you plot every pixel using sum of its coordinates modulo 40 as color, you get a&nbsp;nice-looking diagonal stripes effect. Because of the initially incomprehensible inline assembly snippets appearing all over the place, I&nbsp;eventually learned x86 assembly, too.</p><p><img src="/img/blog/stripes.png"></p><p>Back to&nbsp;2012: I’ve long been wanting to&nbsp;hack on something just for pure fun, a&nbsp;side pet project. Writing code for the bare metal is fun because it’s just about as close as you can get to&nbsp;wielding the ultimate power. And yet, since Clojure is so much fun too, I&nbsp;wanted the project to&nbsp;have something to&nbsp;do&nbsp;with Clojure.</p><p>So here’s <a href='http://github.com/nathell/lithium'>Lithium</a>, an x86 16-bit assembler written in pure Clojure and capable of assembling a&nbsp;binary version of the stripes effect.</p><p>To&nbsp;try it, clone the git repo to&nbsp;your Linux or OS X machine, install DOSBox, launch a&nbsp;REPL with Leiningen, change to&nbsp;the <code>lithium</code> namespace and say:</p><pre><code class="clojure">&#40;run! &quot;/home/you/lithium/src/stripes.li.clj&quot;&#41; | |
| </code></pre><h3>FAQ</h3><p>(Well, this is not really a&nbsp;FAQ since nobody actually asked me any questions about Lithium yet. This is more in anticipation of questions that may arise.)</p><p><strong>What’s the importance of this?</strong></p><p><a href='http://www.physics.ohio-state.edu/~kilcup/262/feynman.html'>None whatsoever</a>. It’s just for fun.</p><p><strong>How complete is it?</strong></p><p>Very incomplete. To&nbsp;even call it pre-pre-alpha would be an exaggeration. It’s currently little more than pure minimum required to&nbsp;assemble <code>stripes.li.clj</code>. Output format wise, it only produces bare binaries (similar to&nbsp;DOS .COMs), and that’s unlikely to&nbsp;change anytime soon.</p><p><strong>Do&nbsp;you intend to&nbsp;continue developing it?</strong></p><p>Absolutely. I&nbsp;will try to&nbsp;make it more complete, add 32- and possibly 64-bit modes, see how to&nbsp;add a&nbsp;macro system (since the input is s-expressions, it should be easy to&nbsp;produce Clojure macros to&nbsp;write assembly), write something nontrivial in it, and see how it can be used as a&nbsp;backend for some higher-level language compiler (I’m not sure yet which language that will turn out to&nbsp;be).</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2012-04-25:post:how-to-call-a-private-function-in-clojure</a:id> | |
| <a:title>How to call a private function in Clojure</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2012/04/25/how-to-call-a-private-function-in-clojure/"/> | |
| <a:updated>2012-04-25T00:00:00Z</a:updated> | |
| <a:content type="html"><p><strong>tl;dr:</strong> Don’t do&nbsp;it. If you really have to, use <code>&#40;#'other-library/private-function args&#41;</code>.</p><p><hr></p><p>A&nbsp;private function in Clojure is one that has been defined using the <code>defn-</code> macro, or equivalently by setting the metadata key <code>:private</code> to&nbsp;<code>true</code> on the var that holds the function. It is normally not allowed in Clojure to&nbsp;call such functions from outside of the namespace where they have been defined. Trying to&nbsp;do&nbsp;so results in an <code>IllegalStateException</code> stating that the var is not public.</p><p>It is possible to&nbsp;circumvent this and call the private function, but it is not recommended. That the author of the library decided to&nbsp;make a&nbsp;function private probably means that he considers it to&nbsp;be an implementation detail, subject to&nbsp;change at any time, and that you should not rely on it being there. If you think it would be useful to&nbsp;have this functionality available as part of the public API, your best bet is to&nbsp;contact the library author and consult the change, so that it may be included officially in a&nbsp;future version.</p><p>Contacting the author, however, is not always feasible: she may not be available or you might be in haste. In this case, several workarounds are available. The simplest is to&nbsp;use <code>&#40;#'other-library/private-function args&#41;</code>, which works in Clojure 1.2.1 and 1.3.0 (it probably works in other versions of Clojure as well, but I&nbsp;haven’t checked that).</p><p>Why does this work? When the Clojure compiler encounters a&nbsp;form <code>&#40;sym args&#41;</code>, it invokes <code>analyzeSeq</code> on that form. If its first element is a&nbsp;symbol, it proceeds to&nbsp;analyze that symbol. One of the first operation in that analysis is checking if it names an inline function, by calling <code>isInline</code>. That function looks into the metadata of the Var named by the symbol in question. If it’s not public, it <a href='https://github.com/clojure/clojure/blob/clojure-1.3.0/src/jvm/clojure/lang/Compiler.java#L6281'>throws an exception</a>.</p><p>On the other hand, <code>#'</code> is the reader macro for var. So our workaround is equivalent to&nbsp;<code>&#40;&#40;var other-library/private-function&#41; args&#41;</code>. In this case, the first element of the form is not a&nbsp;symbol, but a&nbsp;form that evaluates to&nbsp;a&nbsp;var. The compiler is not able to&nbsp;check for this so it does not insert a&nbsp;check for privateness. So the code compiles to&nbsp;calling a&nbsp;Var object.</p><p>Here’s the catch: Vars are callable, just like functions. They <a href='https://github.com/clojure/clojure/blob/clojure-1.3.0/src/jvm/clojure/lang/Var.java#L18'>implement <code>IFn</code></a>. When a&nbsp;var is called, it delegates the call to&nbsp;the <code>IFn</code> object it is holding. This has been recently <a href='https://groups.google.com/d/msg/clojure/1Su9o_8JZ8g/uZL-n4uRSiUJ'>discussed on the Clojure group</a>. Since that delegation does not check for the var’s privateness either, the net effect is that we&nbsp;are able to&nbsp;call a&nbsp;private function this way.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2012-04-12:post:lifehacking-gumtree</a:id> | |
| <a:title>Lifehacking: How to get cheap home equipment using Clojure</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2012/04/12/lifehacking-gumtree/"/> | |
| <a:updated>2012-04-12T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve moved to&nbsp;London last September. Like many new Londoners, I&nbsp;have changed accommodation fairly quickly, being already after one removal and with another looming in a&nbsp;couple of months; my current flat was largely unfurnished when I&nbsp;moved in, so I&nbsp;had to&nbsp;buy some basic homeware. I&nbsp;didn’t want to&nbsp;invest much in it, since it’d be only for a&nbsp;few months. Luckily, it is not hard to&nbsp;do&nbsp;that cheaply: many people are moving out and getting rid of their stuff, so quite often you can search for the desired item on <a href='http://www.gumtree.com/london'>Gumtree</a> and find there’s a&nbsp;cheap one a&nbsp;short bike ride away.</p><p>Except when there isn’t. In this case, it’s worthwhile to&nbsp;check again within a&nbsp;few days as new items are constantly being posted. Being lazy, I’ve decided to&nbsp;automate this. A&nbsp;few hours and a&nbsp;hundred lines of Clojure later, <a href='https://github.com/nathell/gumtree-scraper'>gumtree-scraper</a> was born.</p><p>I’ve packaged it using <code>lein uberjar</code> into a&nbsp;standalone jar, which, when run, produces a&nbsp;<code>gumtree.rss</code> that is included in my Google Reader subscriptions. This way, whenever something I’m interested in appears, I&nbsp;get notified within an hour or so.</p><p>It’s driven by a&nbsp;Google spreadsheet. I’ve created a&nbsp;sheet that has three columns: item name, minimum price, maximum price; then I’ve made it available to&nbsp;anyone who knows the URL. This way I&nbsp;can edit it pretty much from everywhere without touching the script. Each time the script is run (by cron), it downloads that spreadsheet as a&nbsp;CSV that looks like this:</p><pre><code class="nohighlight">hand blender,,5 | |
| bike rack,,15 | |
| </code></pre><p>For each row the script queries Gumtree’s category “For Sale” within London given the price range, gets each result and transforms it to&nbsp;a&nbsp;RSS entry.</p><p>Gumtree has no API, so I’m using screenscraping to&nbsp;retrieve all the data. Because the structure of the pages is much simpler, I’m actually scraping the <a href='http://m.gumtree.com/'>mobile version</a>; a&nbsp;technical twist here is that the mobile version is only served to&nbsp;actual browsers so I’m supplying a&nbsp;custom User-Agent, pretending to&nbsp;be Safari. For actual scraping, the code uses <a href='https://github.com/cgrand/enlive'>Enlive</a>; it works out nicely.</p><p>About half of the code is RSS generation — mostly XML emitting. I’d use <code>clojure.xml/emit</code> but it’s known to&nbsp;<a href='http://clojure-log.n01se.net/date/2012-01-03.html#17:28a'>produce malformed XML</a> at times, so I&nbsp;include a&nbsp;variant that should work.</p><p>In case anyone wants to&nbsp;tries it out, be aware that the location and category are hardcoded in the search URL template; if you want, change the template line in <code>get-page</code>. The controller spreadsheet URL is not, however, hardcoded; it’s built up using the <code>spreadsheet.key</code> system property. Here’s the wrapper script I&nbsp;use that is actually run by cron:</p><pre><code class="bash">#!/bin/bash | |
| if &#91; &quot;`ps ax | grep java | grep gumtree`&quot; &#93;; then | |
| echo &quot;already running, exiting&quot; | |
| exit 0 | |
| fi | |
| cd &quot;`dirname $0`&quot; | |
| java -Dspreadsheet.key=MY&#95;SECRET&#95;KEY -jar $HOME/gumtree/gumtree.jar | |
| cp $HOME/gumtree/gumtree.rss $HOME/public&#95;html | |
| </code></pre><p>Now let me remove that entry for a&nbsp;blender — I’ve bought one yesterday for £4…</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2012-03-21:post:court-with-an-api</a:id> | |
| <a:title>Ever wanted to programmatically file a lawsuit? In Poland, you can.</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2012/03/21/court-with-an-api/"/> | |
| <a:updated>2012-03-21T00:00:00Z</a:updated> | |
| <a:content type="html"><p>This has somehow escaped me: just over a&nbsp;year ago, the Sixth Civil Division of the Lublin-West Regional Court in Lublin, Poland, has opened its <a href='https://www.e-sad.gov.pl/'>online branch</a>. It serves the entire territory of Poland and is competent to&nbsp;recognize lawsuits concerning payment claims. There is <a href='https://www.e-sad.gov.pl/Subpage.aspx?page_id=35'>basic information</a> available in English. It has proven immensely popular, having processed about two million cases in its first year of operation.</p><p>And the really cool thing is, <i>they have an API</i>.</p><p>It’s SOAP-based and has a&nbsp;<a href='https://www.e-sad.gov.pl/Subpage.aspx?page_id=32'>publicly available spec</a>. (Due to&nbsp;the way their web site is constructed, I&nbsp;cannot link to&nbsp;the spec directly; this last link leads to&nbsp;a&nbsp;collection of files related to&nbsp;the web service. The spec is called <code>EpuWS&#95;ver.1.14.1.pdf</code>; it’s in Polish only, but it should be easy to&nbsp;run it through Google Translate.) There are a&nbsp;couple of XML schemas as well, plus the spec contains links to&nbsp;a&nbsp;WSDL and some code samples (in C#) at the end.</p><p>To&nbsp;actually use the API, you need to&nbsp;get yourself an account of the appropriate type (there are two types corresponding to&nbsp;two groups of methods one can use: that of a&nbsp;bailiff and of a&nbsp;mass plaintiff). You then log on to&nbsp;the system, where you can create an API key that is later used for authentication. They throttle the speed down to&nbsp;1 req/s per user to&nbsp;mitigate DoS attacks.</p><p>The methods include <code>FileLawsuits</code>, <code>FileComplaints</code>, <code>SupplyDocuments</code>, <code>GetCaseHistory</code> and so on (the actual names are in Polish). To&nbsp;give you an example, the <code>FileLawsuits</code> method returns a&nbsp;structure that consists of, <i>inter alia</i>, the amount of court fee to&nbsp;pay, the value of the matter of dispute (both broken down into individual lawsuits), and a&nbsp;status code with a&nbsp;description.</p><p>iOS app, anyone?</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-12-09:post:combining-virtual-sequences</a:id> | |
| <a:title>Combining virtual sequences<br>or, Sequential Fun with Macros<br>or, How to Implement Clojure-Like Pseudo-Sequences with Poor Man’s Laziness in a Predominantly Imperative Language</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/12/09/combining-virtual-sequences/"/> | |
| <a:updated>2011-12-09T00:00:00Z</a:updated> | |
| <a:content type="html"><h2>Sequences and iteration</h2><p>There are a&nbsp;number of motivations for this post. One stems from my extensive exposure to&nbsp;Clojure over the past few years: this was, and still is, my primary programming language for everyday work. Soon, I&nbsp;realized that much of the power of Clojure comes from a&nbsp;<i>sequence</i> abstraction being one of its central concepts, and a&nbsp;standard library that contains many sequence-manipulating functions. It turns out that by combining them it is possible to&nbsp;solve a&nbsp;wide range of problems in a&nbsp;concise, high-level way. In contrast, it pays to&nbsp;think in terms of whole sequences, rather than individual elements.</p><p>Another motivation comes from a&nbsp;classical piece of functional programming humour, <a href=''>The Evolution of a&nbsp;Haskell Programmer</a>. If you don’t know it, go check it out: it consists of several Haskell implementations of factorial, starting out from a&nbsp;straightforward recursive definition, passing through absolutely hilarious versions involving category-theoretical concepts, and finally arriving at this simple version that is considered most idiomatic:</p><pre><code class="haskell">fac n = product &#91;1..n&#93; | |
| </code></pre><p>This is very Clojure-like in that it involves a&nbsp;sequence (a&nbsp;list comprehension). In Clojure, this could be implemented as</p><pre><code class="clojure">&#40;defn fac &#91;n&#93; | |
| &#40;reduce &#42; 1 &#40;range 1 &#40;inc n&#41;&#41;&#41; | |
| </code></pre><p>Now, I&nbsp;thought to&nbsp;myself, how would I&nbsp;write factorial in an imperative language? Say, Pascal?</p><pre><code class="pascal">function fac&#40;n : integer&#41; : integer; | |
| var | |
| i, res : integer; | |
| begin | |
| res := 1; | |
| for i := 1 to n do | |
| res := res &#42; i; | |
| fac := res; | |
| end; | |
| </code></pre><p>This is very different from the functional version that works with sequences. It is much more elaborate, introducing an explicit loop. On the other hand, it’s memory efficient: it’s clear that its memory requirements are O(1), whereas a&nbsp;naïve implementation of a&nbsp;sequence would need O(n) to&nbsp;construct it all in memory and then reduce it down to&nbsp;a&nbsp;single value.</p><p>Or is it really that different? Think of the changing values of <code>i</code> in that loop. On first iteration it is 1, on second iteration it’s 2, and so on up to&nbsp;n. Therefore, one can really think of a&nbsp;<code>for</code> loop as a&nbsp;sequence! I&nbsp;call it a&nbsp;“virtual” sequence, since it is not an actual data structure; it’s just a&nbsp;snippet of code.</p><p>To&nbsp;rephrase it as a&nbsp;definition: a&nbsp;virtual sequence is a&nbsp;snippet of code that (presumably repeatedly) <i>yields</i> the member values.</p><h2>Let’s write some code!</h2><p>To&nbsp;illustrate it, throughout the remainder of this article I&nbsp;will be using Common Lisp, for the following reasons:</p><ul><li>It allows for imperative style, including GOTO-like statements. This will enable us to&nbsp;generate very low-level code.</li><li>Thanks to&nbsp;macros, we&nbsp;will be able to&nbsp;obtain interesting transformations.</li></ul><p>Okay, so let’s have a&nbsp;look at how to&nbsp;generate a&nbsp;one-element sequence. Simple enough:</p><pre><code class="lisp">&#40;defmacro vsingle &#40;x&#41; | |
| `&#40;yield ,x&#41;&#41; | |
| </code></pre><p>The name <code>VSINGLE</code> stands for “Virtual sequence that just yields a&nbsp;SINGLE element”. (In general, I&nbsp;will try to&nbsp;define virtual sequences named and performing similarly to&nbsp;their Clojure counterparts here; whenever there is a&nbsp;name clash with an already existing CL function, the name will be prefixed with <code>V</code>.) We&nbsp;will not concern ourselves with the actual definition of <code>YIELD</code> at the moment; for debugging, we&nbsp;can define it just as printing the value to&nbsp;the standard output.</p><pre><code class="lisp">&#40;defun yield &#40;x&#41; | |
| &#40;format t &quot;&#126;A&#126;%&quot; x&#41;&#41; | |
| </code></pre><p>We&nbsp;can also convert a&nbsp;Lisp list to&nbsp;a&nbsp;virtual sequence which just yields each element of the list in turn:</p><pre><code class="lisp">&#40;defmacro vseq &#40;list&#41; | |
| `&#40;loop for x in ,list do &#40;yield x&#41;&#41;&#41; | |
| &#40;defmacro vlist &#40;&amp;rest elems&#41; | |
| `&#40;vseq &#40;list ,@elems&#41;&#41;&#41; | |
| </code></pre><p>Now let’s try to&nbsp;define <code>RANGE</code>. We&nbsp;could use <code>loop</code>, but for the sake of example, let’s pretend that it doesn’t exist and write a&nbsp;macro that expands to&nbsp;low-level GOTO-ridden code. For those of you who are not familiar with Common Lisp, <code>GO</code> is like GOTO, except it takes a&nbsp;label that should be established within a&nbsp;<code>TAGBODY</code> container.</p><pre><code class="lisp">&#40;defmacro range &#40;start &amp;optional end &#40;step 1&#41;&#41; | |
| &#40;unless end | |
| &#40;setf end start start 0&#41;&#41; | |
| &#40;let &#40;&#40;fv &#40;gensym&#41;&#41;&#41; | |
| `&#40;let &#40;&#40;,fv ,start&#41;&#41; | |
| &#40;tagbody | |
| loop | |
| &#40;when &#40;&gt;= ,fv ,end&#41; | |
| &#40;go out&#41;&#41; | |
| &#40;yield ,fv&#41; | |
| &#40;incf ,fv ,step&#41; | |
| &#40;go loop&#41; | |
| out&#41;&#41;&#41;&#41; | |
| </code></pre><p><i>Infinite</i> virtual sequences are also possible. After all, there’s nothing preventing us from considering a&nbsp;snippet of code that loops infinitely, executing <code>YIELD</code>, as a&nbsp;virtual sequence! We&nbsp;will define the equivalent of Clojure’s iterate: given a&nbsp;function <code>fun</code> and initial value <code>val</code>, it will repeatedly generate <code>val</code>, <code>&#40;fun val&#41;</code>, <code>&#40;fun &#40;fun val&#41;&#41;</code>, etc.</p><pre><code class="lisp">&#40;defmacro iterate &#40;fun val&#41; | |
| &#40;let &#40;&#40;fv &#40;gensym&#41;&#41;&#41; | |
| `&#40;let &#40;&#40;,fv ,val&#41;&#41; | |
| &#40;tagbody loop | |
| &#40;yield ,fv&#41; | |
| &#40;setf ,fv &#40;funcall ,fun ,fv&#41;&#41; | |
| &#40;go loop&#41;&#41;&#41;&#41;&#41; | |
| </code></pre><p>So far, we&nbsp;have defined a&nbsp;number of ways to&nbsp;create virtual sequences. Now let’s ask ourselves: is there a&nbsp;way, given code for a&nbsp;virtual sequence, to&nbsp;yield only the elements from the original that satisfy a&nbsp;certain predicate? In other words, can we&nbsp;define a&nbsp;<code>filter</code> for virtual sequences? Sure enough. Just replace every occurrence of <code>yield</code> with code that checks whether the yielded value satisfies the predicate, and only if it does invokes <code>yield</code>.</p><p>First we&nbsp;write a&nbsp;simple code walker that applies some transformation to&nbsp;every <code>yield</code> occurrence in a&nbsp;given snippet:</p><pre><code class="lisp">&#40;defun replace-yield &#40;tree replace&#41; | |
| &#40;if &#40;consp tree&#41; | |
| &#40;if &#40;eql &#40;car tree&#41; 'yield&#41; | |
| &#40;funcall replace &#40;cadr tree&#41;&#41; | |
| &#40;loop for x in tree collect &#40;replace-yield x replace&#41;&#41;&#41; | |
| tree&#41;&#41; | |
| </code></pre><p>We&nbsp;can now write <code>filter</code> like this:</p><pre><code class="lisp">&#40;defmacro filter &#40;pred vseq &amp;environment env&#41; | |
| &#40;replace-yield &#40;macroexpand vseq env&#41; | |
| &#40;lambda &#40;x&#41; `&#40;when &#40;funcall ,pred ,x&#41; &#40;yield ,x&#41;&#41;&#41;&#41;&#41; | |
| </code></pre><p>It is important to&nbsp;point out that since <code>filter</code> is a&nbsp;macro, the arguments are passed to&nbsp;it unevaluated, so if <code>vseq</code> is a&nbsp;virtual sequence definition like <code>&#40;range 10&#41;</code>, we&nbsp;need to&nbsp;macroexpand it before replacing <code>yield</code>.</p><p>We&nbsp;can now verify that <code>&#40;filter #'evenp &#40;range 10&#41;&#41;</code> works. It macroexpands to&nbsp;something similar to</p><pre><code class="lisp">&#40;LET &#40;&#40;#:G70192 0&#41;&#41; | |
| &#40;TAGBODY | |
| LOOP &#40;IF &#40;&gt;= #:G70192 10&#41; | |
| &#40;PROGN &#40;GO OUT&#41;&#41;&#41; | |
| &#40;IF &#40;FUNCALL #'EVENP #:G70192&#41; | |
| &#40;PROGN &#40;YIELD #:G70192&#41;&#41;&#41; | |
| &#40;SETQ #:G70192 &#40;+ #:G70192 1&#41;&#41; | |
| &#40;GO LOOP&#41; | |
| OUT&#41;&#41; | |
| </code></pre><p><code>concat</code> is extremely simple. To&nbsp;produce all elements of <code>vseq1</code> followed by all elements of <code>vseq2</code>, just execute code corresponding to&nbsp;<code>vseq1</code> and then code corresponding to&nbsp;<code>vseq2</code>. Or, for multiple sequences:</p><pre><code class="lisp">&#40;defmacro concat &#40;&amp;rest vseqs&#41; | |
| `&#40;progn ,@vseqs&#41;&#41; | |
| </code></pre><p>To&nbsp;define <code>take</code>, we’ll need to&nbsp;wrap the original code in a&nbsp;block that can be escaped from by means of <code>return-from</code> (which is just another form of <code>goto</code>). We’ll add a&nbsp;counter that will start from <code>n</code> and keep decreasing on each <code>yield</code>; once it reaches zero, we&nbsp;escape the block:</p><pre><code class="lisp">&#40;defmacro take &#40;n vseq &amp;environment env&#41; | |
| &#40;let &#40;&#40;x &#40;gensym&#41;&#41; | |
| &#40;b &#40;gensym&#41;&#41;&#41; | |
| `&#40;let &#40;&#40;,x ,n&#41;&#41; | |
| &#40;block ,b | |
| ,&#40;replace-yield &#40;macroexpand vseq env&#41; | |
| &#40;lambda &#40;y&#41; `&#40;progn &#40;yield ,y&#41; | |
| &#40;decf ,x&#41; | |
| &#40;when &#40;zerop ,x&#41; | |
| &#40;return-from ,b&#41;&#41;&#41;&#41;&#41;&#41;&#41;&#41;&#41; | |
| </code></pre><p><code>rest</code> (or, rather, <code>vrest</code>, as that name is taken) can be defined similarly:</p><pre><code class="lisp">&#40;defmacro vrest &#40;vseq &amp;environment env&#41; | |
| &#40;let &#40;&#40;skipped &#40;gensym&#41;&#41;&#41; | |
| &#40;replace-yield | |
| `&#40;let &#40;&#40;,skipped nil&#41;&#41; ,&#40;macroexpand vseq env&#41;&#41; | |
| &#40;lambda &#40;x&#41; `&#40;if ,skipped &#40;yield ,x&#41; &#40;setf ,skipped t&#41;&#41;&#41;&#41;&#41;&#41; | |
| </code></pre><p><code>vfirst</code> is another matter. It should return a&nbsp;value instead of producing a&nbsp;virtual sequence, so we&nbsp;need to&nbsp;actually execute the code — but with <code>yield</code> bound to&nbsp;something else. We&nbsp;want to&nbsp;establish a&nbsp;block as with <code>take</code>, but our <code>yield</code> will immediately return from the block once the first value is yielded:</p><pre><code class="lisp">&#40;defmacro vfirst &#40;vseq&#41; | |
| &#40;let &#40;&#40;block-name &#40;gensym&#41;&#41;&#41; | |
| `&#40;block ,block-name | |
| &#40;flet &#40;&#40;yield &#40;x&#41; &#40;return-from ,block-name x&#41;&#41;&#41; | |
| ,vseq&#41;&#41;&#41;&#41; | |
| </code></pre><p>Note that so far we’ve seen three classes of macros:</p><ul><li>macros that create virtual sequences;</li><li>macros that transform virtual sequences to&nbsp;another virtual sequences;</li><li>and finally, vfirst is our first example of a&nbsp;macro that produces a&nbsp;result out of a&nbsp;virtual sequence.</li></ul><p>Our next logical step is <code>vreduce</code>. Again, we’ll produce code that rebinds <code>yield</code>: this time to&nbsp;a&nbsp;function that replaces the value of a&nbsp;variable (the accumulator) by result of calling a&nbsp;function on the accumulator’s old value and the value being yielded.</p><pre><code class="lisp">&#40;defmacro vreduce &#40;f val vseq&#41; | |
| `&#40;let &#40;&#40;accu ,val&#41;&#41; | |
| &#40;flet &#40;&#40;yield &#40;x&#41; &#40;setf accu &#40;funcall ,f accu x&#41;&#41;&#41;&#41; | |
| ,vseq | |
| accu&#41;&#41;&#41; | |
| </code></pre><p>We&nbsp;can now build a&nbsp;constructs that executes a&nbsp;virtual sequence and wraps the results up as a&nbsp;Lisp list, in terms of <code>vreduce</code>.</p><pre><code class="lisp">&#40;defun conj &#40;x y&#41; | |
| &#40;cons y x&#41;&#41; | |
| &#40;defmacro realize &#40;vseq&#41; | |
| `&#40;nreverse &#40;vreduce #'conj nil ,vseq&#41;&#41;&#41; | |
| </code></pre><p>Let’s verify that it works:</p><pre><code class="lisp">CL-USER&gt; &#40;realize &#40;range 10&#41;&#41; | |
| &#40;0 1 2 3 4 5 6 7 8 9&#41; | |
| CL-USER&gt; &#40;realize &#40;take 5 &#40;filter #'oddp &#40;iterate #'1+ 0&#41;&#41;&#41;&#41; | |
| &#40;1 3 5 7 9&#41; | |
| </code></pre><p>Hey! Did we&nbsp;just manipulate an <i>infinite</i> sequence and got the result in a&nbsp;<i>finite</i> amount of time? And that without explicit support for laziness in our language? How cool is that?!</p><p>Anyway, let’s finally define our factorial:</p><pre><code class="lisp">&#40;defun fac &#40;n&#41; | |
| &#40;vreduce #'&#42; 1 &#40;range 1 &#40;1+ n&#41;&#41;&#41;&#41; | |
| </code></pre><h2>Benchmarking</h2><p>Factorials grow too fast, so for the purpose of benchmarking let’s write a&nbsp;function that adds numbers from 0 below n, in sequence-y style. First using Common Lisp builtins:</p><pre><code class="lisp">&#40;defun sum-below &#40;n&#41; | |
| &#40;reduce #'+ &#40;loop for i from 0 below n collect i&#41; :initial-value 0&#41;&#41; | |
| </code></pre><p>And now with our virtual sequences:</p><pre><code class="lisp">&#40;defun sum-below-2 &#40;n&#41; | |
| &#40;vreduce #'+ 0 &#40;range n&#41;&#41;&#41; | |
| </code></pre><p>Let’s try to&nbsp;time the two versions. On my Mac running Clozure CL 1.7, this gives:</p><pre><code class="lisp">CL-USER&gt; &#40;time &#40;sum-below 10000000&#41;&#41; | |
| &#40;SUM-BELOW 10000000&#41; took 8,545,512 microseconds &#40;8.545512 seconds&#41; to run | |
| with 2 available CPU cores. | |
| During that period, 2,367,207 microseconds &#40;2.367207 seconds&#41; were spent in user mode | |
| 270,481 microseconds &#40;0.270481 seconds&#41; were spent in system mode | |
| 5,906,274 microseconds &#40;5.906274 seconds&#41; was spent in GC. | |
| 160,000,016 bytes of memory allocated. | |
| 39,479 minor page faults, 1,359 major page faults, 0 swaps. | |
| 49999995000000 | |
| CL-USER&gt; &#40;time &#40;sum-below-2 10000000&#41;&#41; | |
| &#40;SUM-BELOW-2 10000000&#41; took 123,081 microseconds &#40;0.123081 seconds&#41; to run | |
| with 2 available CPU cores. | |
| During that period, 127,632 microseconds &#40;0.127632 seconds&#41; were spent in user mode | |
| 666 microseconds &#40;0.000666 seconds&#41; were spent in system mode | |
| 4 minor page faults, 0 major page faults, 0 swaps. | |
| 49999995000000 | |
| </code></pre><p>As expected, <code>SUM-BELOW-2</code> is much faster, causes less page faults and presumably conses less. (Critics will be quick to&nbsp;point out that we&nbsp;could idiomatically write it using <code>LOOP</code>’s <code>SUM/SUMMING</code> clause, which would probably be yet faster, and I&nbsp;agree; yet if we&nbsp;were reducing by something other than <code>+</code> — something that <code>LOOP</code> has not built in as a&nbsp;clause — this would not be an option.)</p><h2>Conclusion</h2><p>We&nbsp;have seen how snippets of code can be viewed as sequences and how to&nbsp;combine them to&nbsp;produce other virtual sequences. As we&nbsp;are nearing the end of this article, it is perhaps fitting to&nbsp;ask: what are the limitations and drawbacks of this approach?</p><p>Clearly, this kind of sequences is less powerful than “ordinary” sequences such as Clojure’s. The fact that we’ve built them on macros means that once we&nbsp;escape the world of code transformation by invoking some macro of the third class, we&nbsp;can’t manipulate them anymore. In Clojure world, <code>first</code> and <code>rest</code> are very similar; in virtual sequences, they are altogether different: they belong to&nbsp;different worlds. The same goes for <code>map</code> (had we&nbsp;defined one) and <code>reduce</code>.</p><p>But imagine that instead of having just one programming language, we&nbsp;have a&nbsp;high-level language A&nbsp;in which we&nbsp;are writing macros that expand to&nbsp;code in a&nbsp;low-level language B. It is important to&nbsp;point out that the generated code is very low-level. It could almost be assembly: in fact, most of the macros we’ve written don’t even require language B to&nbsp;have composite data-types beyond the type of elements of collections (which could be simple integers)!</p><p>Is there a&nbsp;practical side to&nbsp;this? I&nbsp;don’t know: to&nbsp;me it just seems to&nbsp;be something with hack value. Time will tell if I&nbsp;can put it to&nbsp;good use.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-07-11:post:color-your-own-europe</a:id> | |
| <a:title>Color your own Europe with Clojure!</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/07/11/color-your-own-europe/"/> | |
| <a:updated>2011-07-11T00:00:00Z</a:updated> | |
| <a:content type="html"><p>This is a&nbsp;slightly edited translation of <a href='http://plblog.danieljanus.pl/zippery-w-clojure'>an article</a> I&nbsp;first published on my Polish blog on January 19, 2011. It is meant to&nbsp;target newcomers to&nbsp;Clojure and show how to&nbsp;use Clojure to&nbsp;solve a&nbsp;simple real-life problems.</p><h2>The problem</h2><p>Some time ago I&nbsp;was asked to&nbsp;prepare a&nbsp;couple of differently-colored maps of Europe. I&nbsp;got some datasets which mapped countries of Europe to&nbsp;numerical values: the greater the value, the darker the corresponding color should be. A&nbsp;sample colored map looked like this:</p><p><img src="/img/blog/europa.png"></p><p>I&nbsp;began by downloading an easily editable <a href='http://commons.wikimedia.org/wiki/File:Blank_map_of_Europe.svg'>map</a> from Wikipedia Commons, calculated the required color intensities for the first dataset, launched <a href='http://www.inkscape.org'>Inkscape</a> and started coloring. After half an hour of tedious clicking, I&nbsp;realized that I&nbsp;would be better off writing a&nbsp;simple program in Clojure that would generate the map for me. It turned out to&nbsp;be an easy task: the remainder of this article will be an attempt to&nbsp;reconstruct my steps.</p><h2>SVG</h2><p>The format of the source image is SVG. I&nbsp;knew it was an XML-based vector graphics format, I’d often encountered images in this format on Wikipedia — but editing it by hand was new to&nbsp;me. Luckily, it turned out that the image has a&nbsp;simple structure. Each country’s envelope curve is described with a&nbsp;<code>path</code> element that looks like this:</p><pre><code class="xml">&lt;path | |
| id=&quot;pl&quot; | |
| class=&quot;eu europe&quot; | |
| d=&quot;a long list of curve node coordinates&quot; /&gt; | |
| </code></pre><p>An important thing to&nbsp;note here is the <code>id</code> attribute — this is the two-letter ISO-3166-1-ALPHA2 country code. In fact, there is an informative comment right at the beginning of the image that explains the naming conventions used. Having such a&nbsp;splendid input was of great help.</p><p>Just like HTML, SVG <a href='http://www.w3.org/TR/SVG/styling.html'>uses CSS stylesheets</a> to&nbsp;define the look of an element. All that is needed to&nbsp;color Poland red is to&nbsp;style the element with a&nbsp;<code>fill</code> attribute:</p><pre><code class="xml">&lt;path | |
| id=&quot;pl&quot; | |
| style=&quot;fill: #ff0000;&quot; | |
| class=&quot;eu europe&quot; | |
| d=&quot;a long list of curve node coordinates&quot; /&gt; | |
| </code></pre><p>Now that we&nbsp;know all this, let’s start coding!</p><h2>XML in Clojure</h2><p>The basic way to&nbsp;handle XML in Clojure is to&nbsp;use the <code>clojure.xml</code> namespace, which contains functions that parse XML (on a&nbsp;DOM basis, i.e., into an in-memory tree structure) and serialize such structures back into XML. Let us launch a&nbsp;REPL and start by reading our map and parsing it:</p><pre><code class="clojure">&gt; &#40;use 'clojure.xml&#41; | |
| nil | |
| &gt; &#40;def m &#40;parse &quot;/home/nathell/eur/Blank&#95;map&#95;of&#95;Europe.svg&quot;&#41;&#41; | |
| &#91;...a long while...&#93; | |
| Unexpected end of file from server | |
| &#91;Thrown class java.net.SocketException&#93; | |
| </code></pre><p>Hold on in there! What’s that <code>SocketException</code> doing here? Firefox displays this map properly, so does Chrome, WTF?! Shouldn’t everything work fine in such a&nbsp;great language as Clojure?</p><p>Well, the language is as good as its libraries — and when it comes to&nbsp;Clojure, one can stretch that thought further: Clojure libraries are as good as the Java libraries they use under the hood. In this case, we’ve encountered a&nbsp;feature of the standard Java XML parser (from <code>javax.xml</code> package). It is restrictive and tries to&nbsp;reject invalid documents (even if they are well-formed). If the file being parsed contains a&nbsp;<code>DOCTYPE</code> declaration, the Java parser, and hence <code>clojure.xml/parse</code>, tries to&nbsp;download the DTD schema from the given address and validate the document against that schema. This is unfortunate in many aspects, especially from the point of view of the <a href='http://www.w3.org'>World Wide Web Consortium</a>, since their servers hold the Web standards. One can easily imagine the volume of network traffic this generates: W3C has a&nbsp;<a href='http://www.w3.org/blog/systeam?cat=68'>blog post</a> about it. Many Java programmers have encountered this problem at some time. There are a&nbsp;few solutions; we&nbsp;will go the simplest way and just manually remove the offending <code>DOCTYPE</code> declaration.</p><pre><code class="clojure">&gt; &#40;def m &#40;parse &quot;/home/nathell/eur/bm.svg&quot;&#41;&#41; | |
| #'user/m | |
| &gt; m | |
| &#91;...many screenfuls of numbers...&#93; | |
| </code></pre><p>This time we&nbsp;managed to&nbsp;parse the image. Viewing the structure is not easy because of its sheer size (as expected: the file weighs in at over 0,5 MB!), but from the very first characters of the REPL’s output we&nbsp;can make out that’s it a&nbsp;Clojure map (no pun intended). Let’s examine its keys:</p><pre><code class="clojure">&gt; &#40;keys m&#41; | |
| &#40;:tag :attrs :content&#41; | |
| </code></pre><p>So the map contains three entries with descriptive names. <code>:tag</code> contains the name of the XML element, <code>:attrs</code> is a&nbsp;map of attributes for this element, and <code>:content</code> is a&nbsp;vector of its subelements, each in turn being represented by similarly structured map (or a&nbsp;string if it’s a&nbsp;text node):</p><pre><code class="clojure">&gt; &#40;:tag m&#41; | |
| :svg | |
| &gt; &#40;:attrs m&#41; | |
| {:xmlns &quot;http://www.w3.org/2000/svg&quot;, :width &quot;680&quot;, :height &quot;520&quot;, :viewBox &quot;1754 161 9938 7945&quot;, :version &quot;1.0&quot;, :id &quot;svg2&quot;} | |
| &gt; &#40;count &#40;:content m&#41;&#41; | |
| 68 | |
| </code></pre><p>Just for the sake of practice, let’s try to&nbsp;write the serialized representation of the parsed back as XML. The function <code>emit</code> should be able to&nbsp;do&nbsp;it, but it prints XML to&nbsp;standard output. We&nbsp;can use the <code>with-out-writer</code> macro from the namespace <code>clojure.contrib.io</code> to&nbsp;dump the XML to&nbsp;a&nbsp;file:</p><pre><code class="clojure">&gt; &#40;use 'clojure.contrib.io&#41; | |
| nil | |
| &gt; &#40;with-out-writer &quot;/tmp/a.svg&quot; &#40;emit m&#41;&#41; | |
| nil | |
| </code></pre><p>We&nbsp;try to&nbsp;view <code>a.svg</code> in Firefox and…</p><pre><code class="nohighlight">Error parsing XML: not well-formed | |
| Area: file:///tmp/a.xml | |
| Row 15, column 44: Updated to reflect dissolution of Serbia &amp; Montenegro: http://commons.wikimedia.org/wiki/User:Zirland | |
| -------------------------------------------&#94; | |
| </code></pre><p>It turns out that using <code>clojure.xml/emit</code> is not recommended, because it does not handle XML entities in comments correctly; we&nbsp;should use <code>clojure.contrib.lazy-xml</code> instead. For the sake of example, though, let’s stay with <code>emit</code> and manually remove the offending line once again (we&nbsp;can safely do&nbsp;it, since that’s just a&nbsp;comment).</p><h2>Coloring Poland</h2><p>We&nbsp;saw earlier that our main XML node contains 68 subnodes. Let’s see what they are — tag names will suffice:</p><pre><code class="clojure">&gt; &#40;map :tag &#40;:content m&#41;&#41; | |
| &#40;:title :desc :defs :rect :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :path :g :path :path :g :path :path :path&#41; | |
| </code></pre><p>So far, so good. Seems that all country descriptions are contained directly in the main node. Let us try to&nbsp;find Poland:</p><pre><code>&gt; &#40;count &#40;filter #&#40;and &#40;= &#40;:tag %&#41; :path&#41; | |
| &#40;= &#40;&#40;:attrs %&#41; :id&#41; &quot;pl&quot;&#41;&#41; | |
| &#40;:content m&#41;&#41;&#41; | |
| 1 | |
| </code></pre><p>(This snippet of code filters the list of subnodes of <code>m</code> to&nbsp;pick only those elements whose tag name is <code>path</code> and value of attribute <code>id</code> is <code>pl</code>, and returns the length of such list.) Let’s try to&nbsp;add a&nbsp;<code>style</code> attribute to&nbsp;that element, according to&nbsp;what we&nbsp;said earlier. Because Clojure data structures are immutable, we&nbsp;have to&nbsp;define a&nbsp;new top-level element which will be the same as <code>m</code>, except that we&nbsp;will set the style of the appropriate subnode:</p><pre><code class="clojure">&gt; &#40;def m2 &#40;assoc m | |
| :content | |
| &#40;map #&#40;if &#40;and &#40;= &#40;:tag %&#41; :path&#41; | |
| &#40;= &#40;&#40;:attrs %&#41; :id&#41; &quot;pl&quot;&#41;&#41; | |
| &#40;assoc % :attrs &#40;assoc &#40;:attrs %&#41; :style &quot;fill: #ff0000;&quot;&#41;&#41; | |
| %&#41; | |
| &#40;:content m&#41;&#41;&#41;&#41; | |
| #'user/m2 | |
| &gt; &#40;with-out-writer &quot;/tmp/a.svg&quot; &#40;emit m2&#41;&#41; | |
| nil | |
| </code></pre><p>We&nbsp;open the created file and see a&nbsp;map with Poland colored red. Yay!</p><h2>Generalization</h2><p>We&nbsp;will generalize our code a&nbsp;bit. Let us write a&nbsp;function that colors a&nbsp;single state, taking a&nbsp;<code>path</code> element (subnode of <code>svg</code>) as an argument:</p><pre><code class="clojure">&#40;defn color-state | |
| &#91;{:keys &#91;tag attrs&#93; :as element} colorize-fn&#93; | |
| &#40;let &#91;state &#40;:id attrs&#41;&#93; | |
| &#40;if-let &#91;color &#40;colorize-fn state&#41;&#93; | |
| &#40;assoc element :attrs &#40;assoc attrs :style &#40;str &quot;fill:&quot; color&#41;&#41;&#41; | |
| element&#41;&#41;&#41; | |
| </code></pre><p>This function is similar to&nbsp;the anonymous one we&nbsp;used above in the <code>map</code> call, but differs in some respects. It takes two arguments. As mentioned, the first one is the XML element (destructured into <code>tag</code> and <code>attrs</code>: you can read more about destructuring in <a href='http://clojure.org/special_forms'>the appropriate part of Clojure docs</a>), and the second argument is… a&nbsp;function that should take a&nbsp;two-letter country code and return a&nbsp;HTML color description (or <code>nil</code>, if that country’s color is not specified — <code>color-state</code> will cope with this and return the element unchanged).</p><p>Now that we&nbsp;have <code>color-state</code>, we&nbsp;can easily write a&nbsp;higher-level function that processes and writes XML in one step:</p><pre><code class="clojure">&#40;defn save-color-map | |
| &#91;svg colorize-fn outfile&#93; | |
| &#40;let &#91;colored-map &#40;assoc svg :content &#40;map #&#40;color-state % colorize-fn&#41; &#40;:content svg&#41;&#41;&#41;&#93; | |
| &#40;with-out-writer out | |
| &#40;emit colored-map&#41;&#41;&#41;&#41; | |
| </code></pre><p>Let’s test it:</p><pre><code class="clojure">&gt; &#40;save-color-map m {&quot;pl&quot; &quot;#00ff00&quot;} &quot;/tmp/a.svg&quot;&#41; | |
| nil | |
| </code></pre><p>This time Poland is green (we&nbsp;used a&nbsp;country→color map as an argument to&nbsp;<code>color-state</code>, since Clojure maps are callable like functions). Let’s try to&nbsp;add blue Germany:</p><pre><code class="clojure">&gt; &#40;save-color-map m {&quot;pl&quot; &quot;#00ff00&quot;, &quot;de&quot; &quot;#0000ff&quot;} &quot;/tmp/a.svg&quot;&#41; | |
| nil | |
| </code></pre><p>It works!</p><h2>Problem with the UK</h2><p>Inspired by our success, we&nbsp;try to&nbsp;color different countries. It mostly works, but the United Kingdom remains gray, regardless of whether we&nbsp;specify its code as “uk” or “gb”. We&nbsp;resort to&nbsp;the source of our image, and the beginning comment once again proves helpful:</p><blockquote><p> Certain countries are further subdivided the United Kingdom has gb-gbn for Great Britain and gb-nir for Northern Ireland. Russia is divided into ru-kgd for the Kaliningrad Oblast and ru-main for the Main body of Russia. There is the additional grouping #xb for the “British Islands” (the UK with its Crown Dependencies – Jersey, Guernsey and the Isle of Man) </p></blockquote><p>Perhaps we&nbsp;have to&nbsp;specify “gb-gbn” and “gb-nir”, instead of just “gb”? We&nbsp;try that, but still no luck. After a&nbsp;while of thought: oh yes! Our initial assumption that <i>all</i> the country definitions are <code>path</code> subnodes of the toplevel <code>svg</code> node is false. We&nbsp;have to&nbsp;fix that.</p><p>So far we&nbsp;have been doing a&nbsp;“flat” transform of the SVG tree: we&nbsp;only changed the subnodes of the toplevel node, but no deeper. We&nbsp;should change all the <code>path</code> elements (and <code>g</code>, if we&nbsp;want to&nbsp;color groups of paths like the UK), regardless of how deep they occur in the tree.</p><p>We&nbsp;can use a&nbsp;<a href='http://clojure.org/other_libraries'>zipper</a> to&nbsp;do&nbsp;a&nbsp;depth-first walk of the SVG tree. Let us define a&nbsp;function that takes a&nbsp;zipper, a&nbsp;predicate that tells whether to&nbsp;edit the node in question, and the transformation function to&nbsp;apply to&nbsp;the node if the predicate returns <code>true</code>:</p><pre><code class="clojure">&#40;defn map-zipper &#91;f pred z&#93; | |
| &#40;if &#40;zip/end? z&#41; | |
| &#40;zip/root z&#41; | |
| &#40;recur f pred &#40;-&gt; z &#40;zip/edit #&#40;if &#40;pred %&#41; &#40;f %&#41; %&#41;&#41; zip/next&#41;&#41;&#41;&#41;&#41; | |
| </code></pre><p>Now we&nbsp;rewrite <code>save-color-map</code> as:</p><pre><code class="clojure">&#40;defn save-color-map | |
| &#91;svg colorize-fn outfile&#93; | |
| &#40;let &#91;colored-map &#40;map-zipper #&#40;color-state % colorize-fn&#41; &#40;fn &#91;x&#93; &#40;#{:g :path} &#40;:tag x&#41;&#41;&#41; &#40;zip/xml-zip svg&#41;&#41;&#93; | |
| &#40;with-out-writer out | |
| &#40;emit colored-map&#41;&#41;&#41;&#41; | |
| </code></pre><p>This time the UK can be colored.</p><h2>Colorizers</h2><p>We&nbsp;have automated the process of styling countries to&nbsp;make them appear in color, but translating particular numbers to&nbsp;RGB is tedious. In the last part of this article we&nbsp;will see how to&nbsp;ease this: we&nbsp;are going to&nbsp;write a&nbsp;<i>colorizer</i>, i.e., a&nbsp;function suitable for passing to&nbsp;<code>color-state</code> and <code>save-color-map</code> (so far we’ve been using maps for this).</p><p>Let’s start by writing a&nbsp;function that translates a&nbsp;triplet of numbers into a&nbsp;HTML RGB notation, because it will be easier for us to&nbsp;work with integers than with strings:</p><pre><code class="clojure">&#40;defn htmlize-color | |
| &#91;&#91;r g b&#93;&#93; | |
| &#40;format &quot;#%02x%02x%02x&quot; r g b&#41;&#41; | |
| </code></pre><p>Now we&nbsp;insert a&nbsp;call to&nbsp;<code>htmlize-color</code> into the appropriate pace in <code>color-state</code>:</p><pre><code class="clojure">&#40;defn color-state | |
| &#91;{:keys &#91;tag attrs&#93; :as element} colorize-fn&#93; | |
| &#40;let &#91;state &#40;:id attrs&#41;&#93; | |
| &#40;if-let &#91;color &#40;colorize-fn state&#41;&#93; | |
| &#40;assoc element :attrs &#40;assoc attrs :style &#40;str &quot;fill:&quot; &#40;htmlize-color color&#41;&#41;&#41;&#41; | |
| element&#41;&#41;&#41; | |
| </code></pre><p>Now imagine we&nbsp;have a&nbsp;table with numeric values for states, like this:</p><p><table class="entry"> <tr class="header"><th>State</th><th>Value</th></tr> <tr><td>Poland</td><td class="center">20</td></tr> <tr><td>Germany</td><td class="center">15</td></tr> <tr><td>Netherlands</td><td class="center">30</td></tr> </table></p><p>We&nbsp;want to&nbsp;have a&nbsp;function that assigns colors to&nbsp;states, such that the intensity of a&nbsp;color should be proportional to&nbsp;the value assigned to&nbsp;a&nbsp;given state. To&nbsp;be more general, assume we&nbsp;have two colors, c1 and c2, and for a&nbsp;given state, for each of the R, G, B components we&nbsp;assign a&nbsp;value proportional to&nbsp;the difference between the state’s value and the smallest value in the dataset, normalized to&nbsp;lie between c1 and c2.</p><p>This sounds complex, but I&nbsp;hope an example will clear things up. This is the Clojure implementation of the described algorithm:</p><pre><code class="clojure">&#40;defn make-colorizer | |
| &#91;dataset ranges&#93; | |
| &#40;let &#91;minv &#40;apply min &#40;vals dataset&#41;&#41; | |
| maxv &#40;apply max &#40;vals dataset&#41;&#41; | |
| progress &#40;map &#40;fn &#91;&#91;min-col max-col&#93;&#93; &#40;/ &#40;- max-col min-col&#41; &#40;- maxv minv&#41;&#41;&#41; ranges&#41;&#93; | |
| &#40;into {} | |
| &#40;map &#40;fn &#91;&#91;k v&#93;&#93; &#91;&#40;.toLowerCase k&#41; &#40;map &#40;fn &#91;progress &#91;min-color &#95;&#93;&#93; &#40;int &#40;+ min-color &#40;&#42; &#40;- v minv&#41; progress&#41;&#41;&#41;&#41; progress ranges&#41;&#93;&#41; | |
| dataset&#41;&#41;&#41;&#41; | |
| </code></pre><p>Let us see how it works on our sample data:</p><pre><code class="clojure">&gt; &#40;make-colorizer {&quot;pl&quot; 20, &quot;de&quot; 15, &quot;nl&quot; 30} &#91;&#91;0 255&#93; &#91;0 0&#93; &#91;0 0&#93;&#93;&#41; | |
| {&quot;pl&quot; &#40;85 0 0&#41;, &quot;de&quot; &#40;0 0 0&#41;, &quot;nl&quot; &#40;255 0 0&#41;} | |
| </code></pre><p>The second argument means that the red component is to&nbsp;range between 0 and 255, and the green and blue components are to&nbsp;be fixed at 0.</p><p>Like we&nbsp;wanted, Germany ends up darkest (because it has the least value), the Netherlands is lightest (because it has the greatest value), and Poland’s intensity is one third that of the Netherlands (because 20 is in one third of the way between 15 and 30).</p><h2>Wrapping up</h2><p>The application we&nbsp;created can be further developed in many ways. One can, for instance, add a&nbsp;Web interface for it, or write many different colorizers (e.g., discrete colorizer: fixed colours for ranges of input values, or a&nbsp;temperature colorizer transitioning smoothly from blue through white to&nbsp;red — to&nbsp;do&nbsp;this we&nbsp;would have to&nbsp;pass through the HSV color space).</p><p>What is your idea to&nbsp;improve on it? For those of you who are tired of pasting snippets of code into the REPL, I’m putting the complete source code with a&nbsp;Leiningen project on <a href='https://github.com/nathell/color-europe'>GitHub</a>. Forks are welcome.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-07-08:post:meet-my-little-friend-createtree</a:id> | |
| <a:title>Meet my little friend createTree</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/07/08/meet-my-little-friend-createtree/"/> | |
| <a:updated>2011-07-08T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve recently been developing an iPhone application in my spare time. I’m not going to&nbsp;tell you what it is just yet (I&nbsp;will post a&nbsp;separate entry once I&nbsp;manage to&nbsp;get it into the App Store); for now, let me just say that I’m writing it in JavaScript and HTML5, using <a href=''>PhoneGap</a> and <a href=''>jQTouch</a> to&nbsp;give it a&nbsp;native touch.</p><p>After having written some of code, I&nbsp;began testing it on a&nbsp;real device and encountered a&nbsp;nasty issue. It turned out that some of the screens of my app, containing a&nbsp;dynamically-generated content, sometimes would not show up. I&nbsp;tried to&nbsp;chase the problem down, but it seemed totally random. Finally, I&nbsp;googled up <a href=''>this blog post</a> that gave me a&nbsp;clue.</p><p>My code was using jQuery’s <code>.html&#40;&#41;</code> method (and hence <code>innerHTML</code> under the hood) to&nbsp;display the dynamic content. It turns out that, on Mobile Safari, using <code>innerHTML</code> is highly unreliable (at least on iOS 4.3, but this seems to&nbsp;be a&nbsp;long-standing bug). Sometimes, the change just does not happen. I&nbsp;changed one of my screens, to&nbsp;build and insert DOM objects explicitly, and sure enough, it started to&nbsp;work predictably well.</p><p>So I&nbsp;had to&nbsp;remove all usages of <code>.html&#40;&#41;</code> from my app. The downside to&nbsp;it was that explicit DOM-building code is much more verbose than the version that constructs HTML and then sets it up. It’s tedious to&nbsp;write and contains much boilerplate.</p><p>To&nbsp;not be forced to&nbsp;change code, the above-quoted article advocates using a&nbsp;pure-JavaScript HTML parser outputting DOM to&nbsp;replace jQuery’s <code>.html&#40;&#41;</code> method. I&nbsp;considered this for a&nbsp;while, but finally decided against it — I&nbsp;didn’t want to&nbsp;include another big, complex dependency that potentially could misbehave at times (writing HTML parsers is <i>hard</i>).</p><p>Instead, I&nbsp;came up with this:</p><pre><code class="javascript">function createTree&#40;tree&#41; { | |
| if &#40;typeof tree === 'string' || typeof tree === 'number'&#41; | |
| return document.createTextNode&#40;tree&#41;; | |
| var tag = tree&#91;0&#93;, attrs = tree&#91;1&#93;, res = document.createElement&#40;tag&#41;; | |
| for &#40;var attr in attrs&#41; { | |
| val = attrs&#91;attr&#93;; | |
| if &#40;attr === 'class'&#41; | |
| res.className = val; | |
| else | |
| $&#40;res&#41;.attr&#40;attr, val&#41;; | |
| } | |
| for &#40;var i = 2; i &lt; tree.length; i++&#41; | |
| res.appendChild&#40;createTree&#40;tree&#91;i&#93;&#41;&#41;; | |
| return res; | |
| } | |
| </code></pre><p>This is very similar in spirit to&nbsp;<code>.html&#40;&#41;</code>, except that instead of passing HTML, you give it a&nbsp;data structure representing the DOM tree to&nbsp;construct. It can either be a&nbsp;string (which yields a&nbsp;text node), or a&nbsp;list consisting of the HTML tag name, an object mapping attributes to&nbsp;their values, and zero or more subtrees of the same form. Compare:</p><p>Using <code>.html&#40;&#41;</code>:</p><pre><code class="javascript">var html = '&lt;p&gt;This is an &lt;span class=&quot;red&quot;&gt;example.&lt;/span&gt;&lt;/p&gt;'; | |
| $&#40;'#myDiv'&#41;.html&#40;html&#41;; | |
| </code></pre><p>Using <code>createTree</code>:</p><pre><code class="javascript">var tree = &#91;'p', {}, | |
| 'This is an ', | |
| &#91;'span', {'class': 'red'}, 'example.'&#93;&#93;; | |
| $&#40;'#myDiv'&#41;.empty&#40;&#41;.append&#40;createTree&#40;tree&#41;&#41;; | |
| </code></pre><p>A&nbsp;side benefit is that it is just as easy to&nbsp;build up a&nbsp;tree dynamically as it is to&nbsp;create HTML, and the code often gets clearer. Note how the <code>createTree</code> version above does not mix single and double quotes which is easy to&nbsp;mess up in the <code>.html&#40;&#41;</code> version.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-05-15:post:a-quirk-with-javascript-closures</a:id> | |
| <a:title>A quirk with JavaScript closures</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/05/15/a-quirk-with-javascript-closures/"/> | |
| <a:updated>2011-05-15T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I&nbsp;keep running into this obstacle every now and then. Consider this example:</p><pre><code class="javascript">&gt; q = &#91;&#93; | |
| &#91;&#93; | |
| &gt; for &#40;var i = 0; i &lt; 3; i++&#41; | |
| q.push&#40;function&#40;&#41; { console.log&#40;i&#41;; }&#41;; | |
| &gt; q&#91;0&#93;&#40;&#41; | |
| 3 | |
| </code></pre><p>I&nbsp;wanted an array of three closures, each printing a&nbsp;different number to&nbsp;the console when called. Instead, each prints 3 (or, rather, whatever the value of the variable <code>i</code> happens to&nbsp;be).</p><p>I&nbsp;am not exactly sure about the reason, but presumably this happens because the <code>i</code> in each lambda refers to&nbsp;the <i>variable</i> <code>i</code> itself, not to&nbsp;its binding from the creation time of the function.</p><p>One solution is to&nbsp;enforce the bindings explicitly on each iteration, like this:</p><pre><code class="javascript">for &#40;var i = 0; i &lt; 3; i++&#41; | |
| &#40;function&#40;v&#41; { | |
| q.push&#40;function&#40;&#41; { console.log&#40;v&#41;; }&#41;; | |
| }&#41;&#40;i&#41;; | |
| </code></pre><p>Or use <a href='http://documentcloud.github.com/underscore/'>Underscore.js</a>, which is what I&nbsp;actually do:</p><pre><code class="javascript">&#95;&#40;&#91;1,2,3&#93;&#41;.each&#40;function&#40;i&#41; { | |
| q.push&#40;function&#40;&#41; { console.log&#40;i&#41;; }&#41;; | |
| }&#41;; | |
| </code></pre></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-03-28:post:the-dijkstran-wheel-of-fortune</a:id> | |
| <a:title>The Dijkstran wheel of fortune: SPSS, Excel, VBA</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/03/28/the-dijkstran-wheel-of-fortune/"/> | |
| <a:updated>2011-03-28T00:00:00Z</a:updated> | |
| <a:content type="html"><blockquote><p> It is practically impossible to teach good programming to students that have had a prior exposure to BASIC: as potential programmers they are mentally mutilated beyond hope of regeneration. </p><p> <p style="text-align: right;">— Edsger W. Dijkstra, EWD 498</p> </p></blockquote><p>I&nbsp;like to&nbsp;think of myself somewhat egotistically as a&nbsp;counterexample to&nbsp;the above Dijkstra’s statement. Granted, some of my code is definitely of poor quality, and I&nbsp;dare not call myself a&nbsp;good programmer. But, having started with BASIC on a&nbsp;Commodore 64, then proceeding to&nbsp;learn Pascal (of the Turbo/Borland flavour), then C, x86 assembly, OCaml, Smalltalk, Java, C++, Haskell, Common Lisp, Clojure, and a&nbsp;couple of other languages, with a&nbsp;few enlightenments achieved along the way, I&nbsp;do&nbsp;think I&nbsp;managed to&nbsp;regenerate from the mental wounds that BASIC had inflicted upon me. And now I&nbsp;feel a&nbsp;strange sensation, now that the Dijkstran wheel of fortune has made a&nbsp;full spin: I’ve spend the last few days writing BASIC code. I’ve written several Excel macros in Visual Basic for Applications.</p><p>Why the strange selection of a&nbsp;language? Well, this was simply the best tool for the job. What I&nbsp;needed to&nbsp;do&nbsp;was postprocess the output of some statistical analyses performed in <a href=''>SPSS</a> running under Windows, altering the way the results were presented. SPSS can export data to&nbsp;HTML, Word, and Excel; of these three, the latter is most convenient, because it preserves the structure of the output tables most thoroughly. (In principle, HTML does too, and in fact my first stab was with Clojure, but I&nbsp;stopped after realizing just how much ad-hoc, throwaway code that parses the SPSS-generated HTML, munges it several times to&nbsp;and fro, and then outputs back HTML I’d have to&nbsp;write). So I&nbsp;went the Excel way, and in this post I’d like to&nbsp;share my mixed feelings from that encounter.</p><p>Visual Basic the language is icky. It is certainly a&nbsp;step forward from the BASIC I&nbsp;remember from decades ago, in that I&nbsp;didn’t have to&nbsp;number my lines, and it is possible to&nbsp;structure the code nicely so that it doesn’t contain any GOTOs, GOSUBs or RETURNs. And it has this object-oriented feel to&nbsp;it. But compared to&nbsp;modern languages, programming in it resembles voluntarily putting on handcuffs, and then jumping around to&nbsp;avoid stumbling over the logs it throws under your legs. Not quite so big and scary logs as C++ does, but still. I&nbsp;mean, why on earth does VB have to&nbsp;distinguish between expressions and statements? Many languages do, but in most of them an expression is at least a&nbsp;valid statement. Not so in VB. Also, VB is still line-oriented: whether or not you require an <code>End If</code> in the conditional statement depends on whether it fits in one line or not. But my biggest pain was with the assignments. VB makes a&nbsp;distinction between reference assignments and other assignments, requiring a&nbsp;<code>Set</code> statement in the first case, and disallowing it in the second. So, <code>Set myCell = thatOtherCell</code> but <code>foo = 42</code>. Worse, forgetting the <code>Set</code> in the first case does not result in an error, which makes such bugs very hard to&nbsp;debug. Yurgh.</p><p>Also, the IDE built into Excel for developing VB macros is mediocre. There is an editor, which highlights the syntax and automatically reformats the code, inserting spaces as appropriate, which is nice. It slaps me in face with a&nbsp;modal dialog whenever I&nbsp;make a&nbsp;syntax error and move off the line, which is not so nice. There is a&nbsp;REPL of sorts, taking the form of an “Immediate” window, into which you can type statements (not expressions, remember?) and tap Enter to&nbsp;execute them. You can also <code>Debug.Print</code> to&nbsp;them, like to&nbsp;a&nbsp;JavaScript console. It is not reachable by Ctrl-Tab from the editor, so I&nbsp;ended up using mouse much more often than normally. I&nbsp;want my Emacs back!</p><p>On the other hand, I&nbsp;find the object-oriented API for actually accessing the spreadsheets quite well-designed and pleasant to&nbsp;use. You just grab the object representing your worksheets from the global <code>Worksheets</code> object (indexable by number or by name), and from there you access your cells. The basic object you work with is the <code>Range</code> object, representing either a&nbsp;single cell or a&nbsp;bunch of them; you can get or set cell values, change the formatting, call <code>Offset</code> to&nbsp;navigate around as if with cursor keys. You also can search for specific content in the sheet. Simple enough, easy to&nbsp;use and pick up; and above all, allows to&nbsp;get the job done without getting in the way much.</p><p>As for SPSS itself: it sucks. In fact, it sucks so great and in so many different ways that it merits its own blog entry (which will follow someday). For now, I’ll only note down the things pertaining to&nbsp;Excel interop; hopefully it will save somebody’s time.</p><p>Problem is, SPSS 19’s Excel export is buggy. In fact, it’s so unreliable that I’ve wasted more hours struggling with it than actually writing my macros. (We’re talking SPSS 19 here; I’ve also tried version 17, with the same results.) It exports small data chunks fine, but the larger your output, the more likely it is that Excel alerts about unreadable content in your file. Excel then offers to&nbsp;repair the data, which mostly succeeds, but inevitably loses the formatting — which for me was a&nbsp;no-no.</p><p>So, after long hours of experimentation and attempting different workarounds, I&nbsp;found that it is much, much more reliable to&nbsp;just copy your data and paste it into Excel directly, without exporting to&nbsp;a&nbsp;temporary file. Just do&nbsp;<code>Edit → Copy special</code> and select Excel BIFF format, to&nbsp;make sure you’re copying the right data. If Excel complains about not being able to&nbsp;understand the copied content (turn on the Clipboard preview to&nbsp;find out), save your output to&nbsp;.spv, restart SPSS, re-run your syntax and try again. With luck, it will eventually work. At least for me it did.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-03-11:post:hello-world-again</a:id> | |
| <a:title>Hello world, again</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/03/11/hello-world-again/"/> | |
| <a:updated>2011-03-11T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve been quiet on the front of blogging in English recently. But that doesn’t mean I’ve given up.</p><p>After more than a&nbsp;year, I&nbsp;had become tired of maintaining a&nbsp;<a href='http://blosxom.com/'>Blosxom</a> installation. I&nbsp;greatly admire Blosxom, its minimalism and extensibility, but the default installation is just too minimal for my needs. And the plugins tend to&nbsp;have rough edges. Like the Disqus comments that I’ve enabled at one time on the otherwise static blog pages: the correct number of comments appears in some places but not all; besides, they just don’t feel right.</p><p>So I’ve embarked on an experiment with a&nbsp;blogging platform, namely Posterous. I’ve started a&nbsp;<a href='http://plblog.danieljanus.pl/'>blog in Polish</a> there to&nbsp;comment on local affairs in my mother tongue and to&nbsp;popularize Clojure among Polish programmers. And after a&nbsp;few months, I&nbsp;consider this experiment successful. Posterous supports Markdown, which I&nbsp;grew accustomed to&nbsp;while using Blosxom. It automatically syntax-highlights snippets of Clojure code that I&nbsp;post, which is a&nbsp;big win. It is highly customizable, easy to&nbsp;use (blogging via email FTW!), and lets me control my data. It does have its deficiencies, but on the whole it gets in the way less. So I’m switching to&nbsp;Posterous for “Musings of a&nbsp;Lispnik” too.</p><p>It is unclear for me how to&nbsp;migrate the old content to&nbsp;new platform, so for now I’ll leave it as is under <a href='http://danieljanus.pl/oldblog'>a&nbsp;temporary address</a>, while posting new things exclusively here. (<i>Update 2012-09-24:</i> After another migration, this time to&nbsp;Octopress, I’ve merged the old contents back where it belongs.)</p><p>In the near future, I&nbsp;plan to&nbsp;translate a&nbsp;few articles about Clojure I’d written in Polish and post their English versions here. Stay tuned!</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2011-03-10:post:last-post-here</a:id> | |
| <a:title>Last post here</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2011/03/10/last-post-here/"/> | |
| <a:updated>2011-03-10T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve decided to&nbsp;move my English blog to&nbsp;Posterous. The new address is <a href='http://danieljanus-en.posterous.com'><code>http://danieljanus-en.posterous.com</code></a>. This URL (<a href='http://blog.danieljanus.pl'><code>http://blog.danieljanus.pl</code></a>) will point to&nbsp;the new blog in about a&nbsp;week’s time.</p><p>I’m only posting this to&nbsp;let people update their RSS feeds to&nbsp;the new address, which is</p><p><a href='http://feeds.feedburner.com/MusingsOfALispnik'><code>http://feeds.feedburner.com/MusingsOfALispnik</code></a></p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-05-04:post:defnk</a:id> | |
| <a:title>Keyword arguments</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/05/04/defnk/"/> | |
| <a:updated>2010-05-04T00:00:00Z</a:updated> | |
| <a:content type="html"><p>There’s been an <a href='http://stuartsierra.com/2010/01/15/keyword-arguments-in-clojure'>ongoing</a> <a href='http://www.fatvat.co.uk/2009/01/passing-parameters-in-clojure.html'>debate</a> about how to&nbsp;pass optional named arguments to&nbsp;Clojure functions. One way to&nbsp;do&nbsp;this is the <a href='http://richhickey.github.com/clojure-contrib/def-api.html#clojure.contrib.def/defnk'>defnk</a> macro from <code>clojure.contrib.def</code>; I&nbsp;hesitate to&nbsp;call it <i>canonical</i>, since apparently not everyone uses it, but I’ve found it useful a&nbsp;number of times. Here’s a&nbsp;sample:</p><pre><code class="clojure">user&gt; &#40;use 'clojure.contrib.def&#41; | |
| nil | |
| user&gt; &#40;defnk f &#91;:b 43&#93; &#40;inc b&#41;&#41; | |
| #'user/f | |
| user&gt; &#40;f&#41; | |
| 44 | |
| user&gt; &#40;f :b 100&#41; | |
| 101 | |
| </code></pre><p>This is an example of <i>keyword arguments</i> in action. Keyword arguments are a&nbsp;core feature of some languages, notably <a href='http://www.gigamonkeys.com/book/functions.html#keyword-parameters'>Common Lisp</a> and <a href='http://caml.inria.fr/pub/docs/manual-ocaml/manual006.html#htoc38'>Objective Caml</a>. Clojure doesn’t have them, but it’s pretty easy to&nbsp;emulate their basic usage with macros, as <code>defnk</code> does.</p><p>But there’s more to&nbsp;Common Lisp’s keyword arguments than <code>defnk</code> provides. In CL, the default value of a&nbsp;keyword argument can be an expression referring to&nbsp;other arguments of the same function. For example:</p><pre><code class="lisp">CL-USER&gt; &#40;defun f &#40;&amp;key &#40;a 1&#41; &#40;b a&#41;&#41; | |
| &#40;+ a b&#41;&#41; | |
| F | |
| CL-USER&gt; &#40;f&#41; | |
| 2 | |
| CL-USER&gt; &#40;f :a 45&#41; | |
| 90 | |
| CL-USER&gt; &#40;f :b 101&#41; | |
| 102 | |
| </code></pre><p>I&nbsp;wish <code>defnk</code> had this feature. Or is there some better way that I&nbsp;don’t know of?</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-04-18:post:sunflower</a:id> | |
| <a:title>Sunflower</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/04/18/sunflower/"/> | |
| <a:updated>2010-04-18T00:00:00Z</a:updated> | |
| <a:content type="html"><p>The program I’ve been <a href=''>writing about recently</a> has come to&nbsp;a&nbsp;point where I&nbsp;think it can be shown to&nbsp;the wide public. It’s called <a href=''>Sunflower</a> and has its home on GitHub. It’s nowhere near being completed, and of alpha quality right now, but even at this stage it might be useful.</p><p>Just as sunflower seed kernels come wrapped in hulls, most HTML documents seen in the wild come wrapped in noise that is not really part of the document itself. Take any news site: a&nbsp;document from such a&nbsp;site contains things such as advertisements, header, footer, and many links. Now suppose you have many documents grabbed from the same site. Is it possible to&nbsp;somehow automate the extraction of the document “essences”?</p><p>Sunflower to&nbsp;the rescue. It relies on the assumption that documents coming from the same source have the same structure. It presents a&nbsp;list of strings to&nbsp;the user, and asks to&nbsp;pick those that are contained in the text essence. Then it finds the coordinates of the smallest HTML subtree that contains all those strings, and uses those coordinates to&nbsp;extract information from all documents. And it comes with a&nbsp;nice, easily understandable GUI for that.</p><p>This technique works remarkably well for many collections, although not all. An earlier, proof-of-concept implementation (in Common Lisp) has been used to&nbsp;extract many press texts for the <a href=''>National Corpus of Polish</a>.</p><p>I’ve given up on the symbol-capturing approach to&nbsp;wizards I’ve presented in my previous posts. Inspired by the DOM tree in Web apps, with a&nbsp;bag of elements with identifiers, I&nbsp;now have a&nbsp;central bag of Swing widgets (implemented as an atom) identified by keywords. This bag contains tidbits of the mutable state of Sunflower. This means that I&nbsp;can write callback functions like this:</p><pre><code class="clojure">#&#40;with-components &#91;strings-model selected-dir&#93; | |
| &#40;.removeAllElements strings-model&#41; | |
| &#40;let &#91;p &#40;-&gt; selected-dir htmls first parse&#41;&#93; | |
| &#40;add-component :parsed p&#41; | |
| &#40;doseq &#91;x &#40;strings p&#41;&#93; | |
| &#40;.addElement strings-model x&#41;&#41;&#41;&#41; | |
| </code></pre><p>Name and conquer: having parts of state explicitly named mean that I&nbsp;can reliably access them from just about anywhere. This reduces confusion and allows for less tangled, more self-contained and understandable code.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-04-05:post:symbol-capture</a:id> | |
| <a:title>A case for symbol capture</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/04/05/symbol-capture/"/> | |
| <a:updated>2010-04-05T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Clojure by default protects macro authors from incidentally capturing a&nbsp;local symbol. Stuart Halloway <a href='http://blog.thinkrelevance.com/2008/12/17/on-lisp-clojure-chapter-9'>describes this</a> in more detail, explaining why this is a&nbsp;Good Thing. However, sometimes this kind of symbol capture is called for. I’ve encountered one such case today while hacking a&nbsp;Swing application.</p><p>As I&nbsp;develop the app, I&nbsp;find new ways to&nbsp;express Swing concepts and interact with Swing objects in a&nbsp;more Clojuresque way, so a&nbsp;library of GUI macros and functions gets written. One of them is a&nbsp;<code>wizard</code> macro for easy creation of installer-like wizards, where there is a&nbsp;sequence of screens that can be navigated with <i>Back</i> and <i>Next</i> buttons at the bottom of the window.</p><p>The API (certainly not finished yet) currently looks like this:</p><pre><code class="clojure">&#40;wizard &amp; components&#41; | |
| </code></pre><p>where each Swing <code>component</code> corresponding to&nbsp;one wizard screen can be augmented by a&nbsp;supplementary map, which can contain, <i>inter alia</i>, a&nbsp;function to&nbsp;execute upon showing the screen in question.</p><p>Now, I&nbsp;want those functions to&nbsp;be able to&nbsp;access the <i>Back</i> and <i>Next</i> buttons in case they want to&nbsp;disable or enable them at need. I&nbsp;thus want the API user to&nbsp;be able to&nbsp;use two symbols, <code>back-button</code> and <code>next-button</code>, in the macro body, and have them bound to&nbsp;the corresponding buttons.</p><p>It is crucial that these bindings be lexical and not dynamic. If they were dynamic, they would be only effective during the definition of the wizard, but not when my closures are invoked later on. Thus, my implementation looks like this:</p><pre><code class="clojure">&#40;defmacro wizard &#91;&amp; panels&#93; | |
| `&#40;let &#91;&#126;'back-button &#40;button &quot;&lt; Back&quot;&#41; | |
| &#126;'next-button &#40;button &quot;Next &gt;&quot;&#41;&#93; | |
| &#40;do-wizard &#126;'back-button &#126;'next-button &#126;&#40;vec panels&#41;&#41;&#41;&#41; | |
| </code></pre><p>where <code>do-wizard</code> is a&nbsp;private function implementing the actual wizard creation, and the <code>&#126;'foo</code> syntax forces symbol capture.</p><p>By the way, if all goes well, this blog post should be the first one syndicated to&nbsp;Planet Clojure. Hello, Planet Clojure readers!</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-04-04:post:apennines-hiking</a:id> | |
| <a:title>Hiking in the Apennines</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/04/04/apennines-hiking/"/> | |
| <a:updated>2010-04-04T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve recently done a&nbsp;week-long hike in the Umbria-Marche region of the Italian Apennines (the vicinity of <a href='http://en.wikipedia.org/wiki/Monte_Catria'>Monte Catria</a>, near <a href='http://en.wikipedia.org/wiki/Cantiano'>Cantiano</a>, to&nbsp;be more precise), and here are some tips I’d like to&nbsp;share.</p><ul><li>The Umbria-Marche Apennine doesn’t seem to&nbsp;be frequented by a&nbsp;lot of tourists, especially in mid-March. The information offices, although helpful, are often closed (this is not only the case with the mountain region: contrary to&nbsp;information available on the Web, the tourist information at Forlì airport was closed on Sunday morning), and most of the Italians we’ve met didn’t speak English.</li><li>The tourist trails in the region are not well marked. Direction marks are nowhere to&nbsp;be found, nor are the signs visible on junctions. We&nbsp;had to&nbsp;ask the locals when leaving Cantiano for Monte Tenetra (and ended up on M. Alto instead anyway).</li><li>There are a&nbsp;lot of <i>rifugi</i> (mountain huts), but most of them are closed at this time of year. We&nbsp;passed by six or seven, out of which only one was available for sleep: Rifugio Fonte del Faggio (depicted), merely a&nbsp;small bothy with one worm-eaten bunk bed. Another one, <a href='http://www.montecatria.com/it/rifugi/rifugio_cupa_delle_cotaline.aspx'>Cupa delle Cotaline</a>, with restaurant facilities and situated by a&nbsp;station of a&nbsp;local skilift, opened in the morning, but was closed for the night.</li></ul><p> <img src="/img/blog/faggio.jpg" alt="Rifugio Fonte del Faggio" /></p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-03-31:post:lein-swank</a:id> | |
| <a:title>The pitfalls of <code>lein swank</code></a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/03/31/lein-swank/"/> | |
| <a:updated>2010-03-31T00:00:00Z</a:updated> | |
| <a:content type="html"><p>A&nbsp;couple of weeks ago I&nbsp;finally got around to&nbsp;acquainting myself with <a href=''>Leiningen</a>, one of the most popular build tools for Clojure. The thing that stopped me the most was that Leiningen uses <a href=''>Maven</a> under the hood, which seemed a&nbsp;scary beast at first sight — but once I’ve overcome the initial fear, it turned out to&nbsp;be a&nbsp;quite simple and useful tool.</p><p>One feature in particular is very useful for Emacs users like me: <code>lein swank</code>. You define all dependencies in <code>project.clj</code> as usual, add a&nbsp;magical line to&nbsp;<code>:dev-dependencies</code>, then say</p><pre><code class="nohighlight">$ lein swank | |
| </code></pre><p>and lo and behold, you can <code>M-x slime-connect</code> from your Emacs and have all the code at your disposal.</p><p>There is, however, an issue that you must be aware of when using <code>lein swank</code>: Leiningen uses a&nbsp;custom class loader — <a href=''>AntClassLoader</a> to&nbsp;be more precise — to&nbsp;load the Java classes referenced by the code. Despite being a&nbsp;seemingly irrelevant thing — an implementation detail — this can bite you in a&nbsp;number of most surprising and obscure ways. Try evaluating the following code in a&nbsp;Leiningen REPL:</p><pre><code class="clojure">&#40;str &#40;.decode | |
| &#40;java.nio.charset.Charset/forName &quot;ISO-8859-2&quot;&#41; | |
| &#40;java.nio.ByteBuffer/wrap | |
| &#40;into-array Byte/TYPE &#40;map byte &#91;-79 -26 -22&#93;&#41;&#41;&#41;&#41;&#41; | |
| ;=&gt; &quot;???&quot; | |
| </code></pre><p>The same code evaluated in a&nbsp;plain Clojure REPL will give you <code>&quot;ąćę&quot;</code>, which is a&nbsp;string represented in ISO-8859-2 by the three bytes from the above snippet.</p><p>Whence the difference? Internally, each charset is represented as a&nbsp;unique instance of its specific class. These are loaded lazily as needed by the <code>Charset/forName</code> method. Presumably, the system class loader is used for that, and somewhere along the way a&nbsp;<code>SecurityException</code> gets thrown and caught.</p><p>Note also that there are parts of Java API which use the charset lookup under the hood and are thus vulnerable to&nbsp;the same problem, for example <code>Reader</code> constructors taking charset names. If you use <code>clojure.contrib.duck-streams</code>, then rebinding <code>&#42;default-encoding&#42;</code> will not work from a&nbsp;Leiningen REPL. Jars and überjars produced by Leiningen should be fine, though.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-02-16:post:downcasing</a:id> | |
| <a:title>Downcasing strings</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/02/16/downcasing/"/> | |
| <a:updated>2010-02-16T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I&nbsp;just needed to&nbsp;convert a&nbsp;big (around 200 MB) text file, encoded in UTF-8 and containing Polish characters, all into lowercase. <code>tr</code> to&nbsp;the rescue, right? Well, not quite.</p><pre><code class="nohighlight">$ echo ŻŹŚÓŃŁĘĆĄ | tr A-ZĄĆĘŁŃÓŚŹŻ a-ząćęłńóśźż | |
| żźśóńłęćą | |
| </code></pre><p>Looks reasonable (apart from the fact that I&nbsp;need to&nbsp;specify an explicit character mapping — it would be handy to&nbsp;just have a&nbsp;lcase utility or suchlike); but here’s what happens on another random string:</p><pre><code class="nohighlight">$ echo abisyński | tr A-ZĄĆĘŁŃÓŚŹŻ a-ząćęłńóśźż | |
| abisyŅski | |
| </code></pre><p>I&nbsp;was just about to&nbsp;report this as a&nbsp;bug, when I&nbsp;spotted the following in the manual:</p><blockquote><p> Currently <code>tr</code> fully supports only single-byte characters. Eventually it will support multibyte characters; when it does, the <code>-C</code> option will cause it to complement the set of characters, whereas <code>-c</code> will cause it to complement the set of values. </p></blockquote><p>Turns out some of the basic tools don’t support multibyte encodings. <code>dd conv=lcase</code>, for instance, doesn’t even pretend to&nbsp;touch non-ASCII letters, and perl’s <code>tr</code> operator likewise fails miserably even when one specifies <code>use utf8</code>.</p><p>This is a&nbsp;sad, sad state of affairs. It’s 2010, UTF-8 has been around for seventeen years, and it’s still not supported by one of the core operating system components as other encodings are becoming more and more obsolete. I’m dreaming of the day my system uses it internally for everything.</p><p>Fortunately, not everything is broken. Gawk, for example, works:</p><pre><code class="nohighlight">$ echo koŃ i żÓłw | gawk '{ print tolower&#40;$0&#41;; }' | |
| koń i żółw | |
| </code></pre><p>and so does sed.</p><p><i>Update 2010-04-04:</i> I&nbsp;should have been more specific. The above rant applies to&nbsp;the GNU tools (<code>tr</code> and <code>dd</code>) as found in most Linux distributions; other versions can be more featureful. As <a href='http://alexott.net/'>Alex Ott</a> points out in an email comment, tr on OS X works as expected for characters outside of ASCII, and also supports character classes as in <code>tr '&#91;:upper:&#93;' '&#91;:lower:&#93;'</code>. This is yet another testimony to&nbsp;general high quality of Apple software; in this particular case, though, it may well be a&nbsp;direct effect of OS X’s BSD heritage. Does it work on *BSD?</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-02-10:post:clojure-set</a:id> | |
| <a:title>Clojure SET</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/02/10/clojure-set/"/> | |
| <a:updated>2010-02-10T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve just taken a&nbsp;short breath off work to&nbsp;put <a href='http://github.com/nathell/setgame'>some code</a> on GitHub that I&nbsp;had written over one night some two months ago. It is an implementation of the <a href='http://en.wikipedia.org/wiki/Set_(game)'>Set</a> game in Clojure, using Swing for GUI.</p><p>I&nbsp;do&nbsp;not have time to&nbsp;clean up or comment the code, so I’m leaving it as is for now; however, I&nbsp;hope that even in its current state it can be of interest, especially for Clojure learners.</p><p>Some random notes on the code:</p><ul><li>Clojure is concise! The whole thing is just under 250 lines of code, complete with game logic and the GUI. Of these, the logic is about 50 LOC. Despite this it reads clearly and has been a&nbsp;pleasure to&nbsp;write, thanks to&nbsp;Clojure’s supports for sets as a&nbsp;data structure (in vein of the game’s title and theme).</li><li>There are no graphics included. All the drawing is done in the GUI part of code (I’ve replaced the canonical squiggle shape by a&nbsp;triangle and stripes by gradients, for the sake of easier drawing).</li><li>I’ve toyed around with different Swing layout managers for this game. Back in the days when I&nbsp;wrote in plain Java, I&nbsp;used to&nbsp;use <a href='https://tablelayout.dev.java.net/'>TableLayout</a>, but it has a&nbsp;non-free license; <a href='http://www.jgoodies.com/freeware/forms/'>JGoodies Forms</a> is also nice, but has a&nbsp;slightly more complicated API (and it’s an additional dependency, after all). In the end I’ve settled with the standard GridBagLayout, which is similar in spirit to&nbsp;those two, but requires more boilerplate to&nbsp;set up. As it turned out, simple macrology makes it quite pleasurable to&nbsp;use; see <code>add-gridbag</code> in the code for details.</li><li>Other things of interest might be my function to&nbsp;randomly shuffle seqs, which strikes a&nbsp;nice balance between simplicity/conciseness of implementation and randomness; and a&nbsp;useful debugging macro.</li></ul><p>Comments?</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2010-01-18:post:reactivation</a:id> | |
| <a:title>Reactivation (and some ramblings on my blogging infrastructure)</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2010/01/18/reactivation/"/> | |
| <a:updated>2010-01-18T00:00:00Z</a:updated> | |
| <a:content type="html"><p>This blog has not seen content updates in more than a&nbsp;year. Plenty of things can happen in such a&nbsp;long period, and in fact many aspect of my life have seen major changes over this time. I’m not, however, going to&nbsp;write a&nbsp;lengthy post about all that right now. Instead, I&nbsp;just would like to&nbsp;announce the reactivation of the blog.</p><p>You might have noticed that many things have changed. First, the blog has a&nbsp;new address: <a href='http://blog.danieljanus.pl'><code>http://blog.danieljanus.pl</code></a>; the address of the RSS feed has also changed and is now <a href='http://blog.danieljanus.pl/index.rss'><code>http://blog.danieljanus.pl/index.rss</code></a> — please update your readers!</p><p>Probably the most important change is that you now may post comments under the entries, even though this blog continues to&nbsp;be just a&nbsp;bunch of static HTML pages. This is possible thanks to&nbsp;the <a href='http://disqus.com/'>Disqus</a> service. I&nbsp;wonder whether it will encourage people to&nbsp;give feedback: I&nbsp;have received very few email comments since I&nbsp;started blogging. Also, the static calendar at the top of each page is gone, replaced by a&nbsp;bunch of links to&nbsp;archive posts.</p><p>I&nbsp;have long been considering changing <a href='http://www.blosxom.com/'>Blosxom</a> to&nbsp;something else. The main reason for such a&nbsp;step is that it’s written in Perl, which makes it particularly hard to&nbsp;debug upon encountering an unexpected behaviour. The single most irritating thing was that Blosxom would unexpectedly change the date of a&nbsp;post that was edited (which did not let me fix typos and other glitches); I&nbsp;found a&nbsp;patch for this somewhere, but lost it.</p><p>On the other hand, I&nbsp;really liked — and still like — Blosxom’s minimalistic approach and the ease of adding posts. (The very idea of installing a&nbsp;monstrosity such as Wordpress, with its gazillion of features I&nbsp;don’t need, posts kept in a&nbsp;database and what not, makes me feel dizzy.) I&nbsp;fiddled for a&nbsp;while with the thought of reimplementing Blosxom in Common Lisp, but that turned out to&nbsp;be a&nbsp;more time-consuming project than it initially seemed. So when I&nbsp;found <a href='http://blosxom.ookee.com/'>The Unofficial Blosxom User Group</a> and learned that, contrary to&nbsp;my belief, Blosxom is still actively maintained and has a&nbsp;thriving community, I&nbsp;ended up staying with the original Perl version, refining my installation so that it no longer gets in the way (<a href='http://blosxom.ookee.com/blog/help/howto_update_posts_without_making_the_date_change.html'>this FAQ entry</a> did the trick). I&nbsp;also rewrote all my source text files to&nbsp;<a href='http://daringfireball.net/projects/markdown/'>Markdown</a>, which made them vastly more readable and easy to&nbsp;edit, updating links and adding short followup notes where appropriate, but otherwise leaving old entries as they were.</p><p>I’d like to&nbsp;thank <a href='http://www.3ofcoins.net/2010/01/08/revive-the-blog-project-52/'>Maciek Pasternacki</a> for inspiring me to&nbsp;finally get around to&nbsp;this. While my plans are not as ambitious as his — I&nbsp;am not courageous enough to&nbsp;publicly prove my perseverance, so my blogging will likely continue to&nbsp;be irregular — I&nbsp;plan to&nbsp;write more (having accumulated many ideas for blog posts) and I&nbsp;hope the periods of silence will be much shorter than hitherto.</p><p>I&nbsp;would like to&nbsp;take this opportunity to&nbsp;wish my readers all the best in the New Year!</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2009-01-02:post:google-books</a:id> | |
| <a:title>Google Books</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2009/01/02/google-books/"/> | |
| <a:updated>2009-01-02T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Yesterday, upon a&nbsp;midnight dreary, while I&nbsp;pondered, weak and weary, over <a href='http://mitpress.mit.edu/algorithms/'>a&nbsp;renowned volume of the olden lore</a> (and specifically, upon one of the problems contained in the Polish translation of the first edition), I&nbsp;suddenly felt a&nbsp;need to&nbsp;consult the original version, to&nbsp;check whether there are no mistranslations or unincluded corrections for my copy. So I&nbsp;headed for <a href='http://books.google.com/'>Google Book Search</a>, and apart from finding what I&nbsp;needed, I&nbsp;followed a&nbsp;link that sounded interesting. Quoth the link, <a href='http://books.google.com/googlebooks/agreement/'>“Groundbreaking Agreement”</a>.</p><p>Basically, what it all boils to&nbsp;is two pieces of news — you guessed it, a&nbsp;good one and a&nbsp;bad one. The good news is that Google have come to&nbsp;agreement with several major U.S. publishers that will allow them to&nbsp;provide online access to&nbsp;digitized copies of out-of-print but still copyrighted books. <i>Lots</i> of books, and even though the service is not going to&nbsp;be free, that means all this richness will be at the fingertips — no more need to&nbsp;travel half the world to&nbsp;the Library of Congress to&nbsp;get one of the rare copies we’re after. Sounds cool, huh? Well, here comes the bad news: it will only be available to&nbsp;U.S. citizens.</p><p>Or will it?</p><p>I&nbsp;wonder how are they going to&nbsp;check for this precondition. IP-based geolocalization springs to&nbsp;mind. And unless they blacklist some IPs or restrict the credit cards used for payment, all I&nbsp;will need is some proxy on some server physically in the U.S. Say, a&nbsp;shell account on someone’s Linux box. I&nbsp;remember reading a&nbsp;Polish blog post about gaining access to&nbsp;American-exclusive content of some website (last.fm I&nbsp;believe it was) in a&nbsp;similar way. Hmm, hmm. We&nbsp;will see.</p><p>So, anyone got a&nbsp;shell account to&nbsp;spare?</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-12-18:post:fighting-procrastination</a:id> | |
| <a:title>anti-procrastination.el</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/12/18/fighting-procrastination/"/> | |
| <a:updated>2008-12-18T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Fighting procrastination has been my major concern these days. I’ve devised a&nbsp;number of experimental tools to&nbsp;help me with that. One of them is called <a href='http://bach.ipipan.waw.pl/~nathell/projects/snafu.php'>snafu</a> and can generate reports of your activity throughout the whole day of work. It’s in a&nbsp;preliminary state, but works (at least since I’ve found and fixed a&nbsp;long-standing bug in it which would cause it to&nbsp;barf every now and then), and I&nbsp;already have a&nbsp;number of ideas for its further expansion.</p><p>Reports alone, however, do&nbsp;not quite muster enough motivation for work. I’m doing most of my editing/programming work in Emacs, so yesterday I&nbsp;grabbed the Emacs Lisp manual and came up with a&nbsp;couple of extra lines at the end of my <code>.emacs</code>.</p><pre><code class="lisp">;;; Written by Daniel Janus, 2008/12/18. | |
| ;;; This snippet is placed into the public domain. Feel free | |
| ;;; to use it in any way you wish. I am not responsible for | |
| ;;; any damage resulting from its usage. | |
| &#40;defvar store-last-modification-time t&#41; | |
| &#40;defvar last-modification-time nil&#41; | |
| &#40;defun mark-last-modification-time &#40;beg end len&#41; | |
| &#40;let &#40;&#40;b1 &#40;substring &#40;buffer-name &#40;current-buffer&#41;&#41; 0 1&#41;&#41;&#41; | |
| &#40;when &#40;and store-last-modification-time | |
| &#40;not &#40;string= b1 &quot; &quot;&#41;&#41; | |
| &#40;not &#40;string= b1 &quot;&#42;&quot;&#41;&#41;&#41; | |
| &#40;setq last-modification-time &#40;current-time&#41;&#41;&#41;&#41;&#41; | |
| &#40;add-hook 'after-change-functions 'mark-last-modification-time&#41; | |
| &#40;defun write-lmt &#40;&#41; | |
| &#40;setq store-last-modification-time nil&#41; | |
| &#40;when last-modification-time | |
| &#40;with-temp-file &quot;/tmp/emacs-lmt&quot; | |
| &#40;multiple-value-bind &#40;a b c&#41; last-modification-time | |
| &#40;princ a &#40;current-buffer&#41;&#41; | |
| &#40;terpri &#40;current-buffer&#41;&#41; | |
| &#40;princ b &#40;current-buffer&#41;&#41;&#41;&#41;&#41; | |
| &#40;setq store-last-modification-time t&#41;&#41; | |
| &#40;run-at-time nil 1 'write-lmt&#41; | |
| </code></pre><p>Every second (to&nbsp;change that to&nbsp;every 10 seconds, change the <code>1</code> to&nbsp;<code>10</code> in the last line) it creates a&nbsp;file named <code>/tmp/emacs-lmt</code> which contains the time of last modification of any non-system buffer.</p><p>That’s all there is to&nbsp;it, at least on the Emacs side. The other part is a&nbsp;simple shell script, which uses <a href='http://www.mplayerhq.hu/'>MPlayer</a> to&nbsp;display a&nbsp;nag-screen for five seconds, and then give me some time to&nbsp;start doing anything useful before nagging me again:</p><pre><code class="bash">#!/bin/bash | |
| TIMEOUT=300 | |
| while true; do | |
| cat /tmp/emacs-lmt | &#40; | |
| read a; read b; | |
| c=&quot;`date +%s`&quot;; | |
| let x=c-65536&#42;a-b; | |
| if test $x -gt $TIMEOUT; | |
| then mplayer -fs $HOME/p.avi; | |
| sleep 15; | |
| fi&#41; | |
| sleep 1 | |
| done | |
| </code></pre><p>The nag-screen in my case is an animation which I’ve created using MEncoder from a&nbsp;single frame which looks <a href='http://bach.ipipan.waw.pl/~nathell/procrastination.png'>like this</a>. Beware the expletives! (This is one of the few cases I&nbsp;find their usage justified, as the strong message bites the conscience more strongly.)</p><p>I’ve only been testing this setup for one day, but so far it’s working flawlessly: I&nbsp;got more done yesterday than for the two previous days combined, and that’s excluding the hour or so that took me to&nbsp;write these snippets.</p><p>If anyone else happens to&nbsp;give it a&nbsp;try, I’d love to&nbsp;hear any comments.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-09-23:post:immensely-powerful-tool</a:id> | |
| <a:title>The immensely powerful tool</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/09/23/immensely-powerful-tool/"/> | |
| <a:updated>2008-09-23T00:00:00Z</a:updated> | |
| <a:content type="html"><p>A&nbsp;pen and a&nbsp;sheet of paper are simple utilities; but there lies vast and sheer power in them that I&nbsp;was not aware of. Up until now. So what can they be used for that one might possibly not realize?</p><p>Short answer: serializing the stream of consciousness.</p><p>Yes, it’s simple, and you may laugh at me now. I&nbsp;myself am a&nbsp;little amazed why I&nbsp;haven’t noticed this before. But this answer lends itself to&nbsp;another question: what good is this serialization, and what exactly do&nbsp;I&nbsp;mean by it, anyway? And the answer to&nbsp;<i>that</i> is a&nbsp;little longer. So here goes.</p><p>I’m one of the people who tend to&nbsp;have problems with concentrating when thinking, especially when thinking hard. This is not to&nbsp;say that I&nbsp;am not capable of thinking hard: I&nbsp;am, but doing so requires a&nbsp;level of concentration that is tricky for me to&nbsp;exert for a&nbsp;prolonged period. (Unless, of course, I&nbsp;am in the state of absolute fascination, where this is taken care of subconsciously. But that’s another story.) More often than not, a&nbsp;tough problem requiring a&nbsp;significant amount of work just has to&nbsp;be dealt with. And then things start to&nbsp;distract attention. There is an itch to&nbsp;scratch, thoughts are shreds, each one pertaining to&nbsp;a&nbsp;tiny bit of the problem, but intertwined with hundreds of other bits of other problems, forming a&nbsp;dense, tangled web, hard to&nbsp;navigate over, and jumping fast from one to&nbsp;another, it becomes more and more unclear what’s next.</p><p>So what can one do? One way is to&nbsp;grab a&nbsp;writing device and just <i>start writing</i>. Running text is linear in nature, so you end up traversing the thought graph depth-first and writing down each thought as you traverse its node. And what’s more, translating ideas to&nbsp;written language <i>slows you down</i>, which is a&nbsp;<a href='http://www.catb.org/jargon/html/G/Good-Thing.html'>Good Thing</a> because it makes you see your way through the graph more consciously. It might take you longer to&nbsp;walk from point A&nbsp;to&nbsp;point B than to&nbsp;drive there by car, but definitely you will see more of the landscape as you go. Arriving at the final destination, or simply putting down the pen because enough thoughts have been collected and serialized (there’s never really any end of the stream), makes you end up with a&nbsp;half-product: an unsmithed lump of ore out of which you can forge ingots.</p><p>But why a&nbsp;pen and paper, as opposed to, say, a&nbsp;text editor? I&nbsp;think any writing utensil would work to&nbsp;some extent, but for me this seems to&nbsp;be the best option, for several reasons. First of all, I&nbsp;can type on the keyboard much faster than I&nbsp;can write legibly by hand, so this further slows down the pace (which is a&nbsp;Good Thing as we&nbsp;have observed already).</p><p>Second, there is something magical in handwriting which a&nbsp;text editor will never be able to&nbsp;achieve: it’s hard to&nbsp;describe. But the net effect is a&nbsp;very evident focus on Here and Now, the pen moving across the paper, the sheet filling up with more and more lines of script. This environment is naturally single-tasked: no Alt-Tab to&nbsp;press to&nbsp;switch to&nbsp;another terminal, no blinking icon of an instant-messaging program (unless a&nbsp;phone happens to&nbsp;ring). This causes synergy with the concentration caused by serializing thoughts.</p><p>If you have never tried this approach, feel free to&nbsp;do&nbsp;so. Although I&nbsp;cannot guarantee it will work for you, it certainly does work for me.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-08-09:post:small-lisp</a:id> | |
| <a:title>Who said Common Lisp programs cannot be small?</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/08/09/small-lisp/"/> | |
| <a:updated>2008-08-09T00:00:00Z</a:updated> | |
| <a:content type="html"><p>So, how much disk space does your average CL image eat up? A&nbsp;hundred megs? Fifty? Twenty? Five, perhaps, if you’re using LispWorks with a&nbsp;tree-shaker? Well then, how about this?</p><pre><code class="nohighlight">&#91;nathell@chamsin salza2-2.0.4&#93;$ ./cl-gzip closures.lisp test.gz | |
| &#91;nathell@chamsin salza2-2.0.4&#93;$ gunzip test | |
| &#91;nathell@chamsin salza2-2.0.4&#93;$ diff closures.lisp test | |
| &#91;nathell@chamsin salza2-2.0.4&#93;$ ls -l cl-gzip | |
| -rwxr-xr-x 1 nathell nathell 386356 2008-08-09 11:08 cl-gzip | |
| </code></pre><p>That’s right. A&nbsp;standalone executable of a&nbsp;mini-gzip, written in Common Lisp, taking up <i>under 400K!</i> And it only depends on glibc and GMP, which are available by default on pretty much every Linux installation. (This is on a&nbsp;32-bit x86 machine, by the way).</p><p>I&nbsp;used the most recent version of <a href='http://ecls.sourceforge.net/'>ECL</a> for compiling this tiny example. The key to&nbsp;the size was configuring ECL with <code>--disable-shared --enable-static CFLAGS=&quot;-Os -ffunction-sections -fdata-sections&quot; LDFLAGS=&quot;-Wl,-gc-sections&quot;</code>. This essentially gives you a&nbsp;poor man’s tree shaker for free at a&nbsp;linker level. And ECL in itself produces comparatively tiny code.</p><p>I&nbsp;built this example from <a href='http://www.xach.com/lisp/salza2'>Salza2</a>’s source by loading the following code snippet:</p><pre><code class="lisp">&#40;defvar salza | |
| '&#40;&quot;package&quot; &quot;reset&quot; &quot;specials&quot; | |
| &quot;types&quot; &quot;checksum&quot; &quot;adler32&quot; &quot;crc32&quot; &quot;chains&quot; | |
| &quot;bitstream&quot; &quot;matches&quot; &quot;compress&quot; &quot;huffman&quot; | |
| &quot;closures&quot; &quot;compressor&quot; &quot;utilities&quot; &quot;zlib&quot; | |
| &quot;gzip&quot; &quot;user&quot;&#41;&#41; | |
| &#40;defvar salza2 | |
| &#40;mapcar &#40;lambda &#40;x&#41; &#40;format nil &quot;&#126;A.lisp&quot; x&#41;&#41; | |
| salza&#41;&#41; | |
| &#40;defvar salza3 | |
| &#40;mapcar &#40;lambda &#40;x&#41; &#40;format nil &quot;&#126;A.o&quot; x&#41;&#41; | |
| salza&#41;&#41; | |
| &#40;defun build-cl-gzip &#40;&#41; | |
| &#40;dolist &#40;x salza2&#41; | |
| &#40;load x&#41; | |
| &#40;compile-file x :system-p t&#41;&#41; | |
| &#40;c:build-program | |
| &quot;cl-gzip&quot; | |
| :lisp-files salza3 | |
| :epilogue-code | |
| '&#40;progn | |
| &#40;in-package :salza2&#41; | |
| &#40;gzip-file &#40;second &#40;si::command-args&#41;&#41; | |
| &#40;third &#40;si::command-args&#41;&#41;&#41;&#41;&#41;&#41; | |
| &#40;build-cl-gzip&#41; | |
| </code></pre><p>(Sadly enough, there’s no ASDF in here. I&nbsp;have yet to&nbsp;figure out how to&nbsp;leverage ASDF to&nbsp;build small binaries in this constrained environment.)</p><p>This gave me a&nbsp;standalone executable 1.2 meg in size. I&nbsp;then proceeded to&nbsp;compress it with <a href='http://upx.sourceforge.net/'>UPX</a> (with arguments <code>--best --crp-ms=999999</code>) and got the final result. How cool is that?</p><p>I&nbsp;am actively looking for a&nbsp;new job. If you happen to&nbsp;like my writings and think I&nbsp;might be just the right man for the team you’re building up, please feel free to&nbsp;consult my <a href='http://bach.ipipan.waw.pl/~nathell/cv-en.pdf'>résumé</a> or pass it on.</p><p><i>Update 2010-Jan-17</i>: the above paragraph is no longer valid.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-06-23:post:cl-morfeusz</a:id> | |
| <a:title>cl-morfeusz: A ninety minutes’ hack</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/06/23/cl-morfeusz/"/> | |
| <a:updated>2008-06-23T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Here’s what I&nbsp;came up with today, after no more than 90 minutes of coding (complete with comments and all):</p><pre><code class="nohighlight">MORFEUSZ&gt; &#40;morfeusz-analyse &quot;zażółć gęślą jaźń&quot;&#41; | |
| &#40;&#40;0 1 &quot;zażółć&quot; &quot;zażółcić&quot; &quot;impt:sg:sec:perf&quot;&#41; | |
| &#40;1 2 &quot;gęślą&quot; &quot;gęśl&quot; &quot;subst:sg:inst:f&quot;&#41; | |
| &#40;2 3 &quot;jaźń&quot; &quot;jaźń&quot; &quot;subst:sg:nom.acc:f&quot;&#41;&#41; | |
| </code></pre><p>This is <a href='http://danieljanus.pl/code/morfeusz.lisp'>cl-morfeusz</a> in action, a&nbsp;Common Lisp interface to&nbsp;<a href='http://nlp.ipipan.waw.pl/~wolinski/morfeusz/'>Morfeusz</a>, the morphological analyser for Polish.</p><p>It’s a&nbsp;single Lisp file, so there’s no ASDF system definition or asdf-installability for now. I’m not putting it under version control, either. Or, should I&nbsp;say, not yet. When I&nbsp;get around to&nbsp;it, I&nbsp;plan to&nbsp;write a&nbsp;simple parser and write a&nbsp;Polish-language version of <a href='http://en.wikipedia.org/wiki/Colossal_Cave_Adventure'>the text adventure that started it all</a>.</p><p>Meanwhile, you may use cl-morfeusz for anything you wish (of course, as long as you comply with Morfeusz’s license). Have fun!</p><p><i>Update 2010-Jan-17</i>: With the advent of UTF-8 support in CFFI, the ugly workarounds in the code are probably no longer necessary; I&nbsp;don’t have time to&nbsp;check it right now, though.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-06-23:post:you-win-some</a:id> | |
| <a:title>You win some, you lose some, you talk some</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/06/23/you-win-some/"/> | |
| <a:updated>2008-06-23T00:00:00Z</a:updated> | |
| <a:content type="html"><p>After my <a href='http://blog.danieljanus.pl/im-not-playing-this-stupid-game-anymore.html'>shameful performance</a> in the previous tournament, this weekend saw my greatest achievement in tournament Scrabble to&nbsp;date: that of advancing to&nbsp;the quarterfinals of the Cup of Poland. For the record, <a href='http://www.pfs.org.pl/turnieje/2008/w080622.txt'>here</a> are the final standings. In the quarterfinal, I&nbsp;lost both games to&nbsp;Tomasz Zwoliński (the former Champion of Poland), who went on to&nbsp;win the Cup.</p><p>On Thursday, I&nbsp;will be delivering a&nbsp;presentation about the dark side of programming: error handling and how to&nbsp;cope up with Murphy’s law. The talk will last around 30 minutes and be held within <a href='http://aulapolska.pl/'>TechAula</a>, a&nbsp;place to&nbsp;hear about exciting and revolutionary technologies in software engineering. Feel invited to&nbsp;register and show up.</p><p>(Postscriptum 11 July: By public demand, the slides from my talk are now <a href='http://danieljanus.pl/2008-aula-errorhandling.pdf'>available for download</a>.)</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-06-19:post:another-metapost</a:id> | |
| <a:title>Another metapost</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/06/19/another-metapost/"/> | |
| <a:updated>2008-06-19T00:00:00Z</a:updated> | |
| <a:content type="html"><p>No, I&nbsp;am not going to&nbsp;write about <a href='http://foundry.supelec.fr/projects/metapost/'>the programming language for generating vector graphics</a>. This is not a&nbsp;real post, but rather a&nbsp;note to&nbsp;self to&nbsp;write ones on certain topics once I&nbsp;get ready for that. And as for today’s title, I&nbsp;just couldn’t resist the pun. ;-)</p><p>I’ve been rewriting the Poliqarp Java (GUI) client for the last two weeks or so. The point is to&nbsp;convert it to&nbsp;use <a href='http://bach.ipipan.waw.pl/~nathell/blog/poliqarp-new-protocol.html'>the new protocol</a>, and to&nbsp;take the opportunity of turning a&nbsp;messy, kludgey and bit-rotting pile of code into a&nbsp;neatly decoupled, cleanly designed, robust and comprehensible utility. And the further I&nbsp;get, the more I&nbsp;see how much it’s worth it. I&nbsp;strongly believe that at the end of this path, upon remergence with the mainline, Poliqarp will become better than ever before.</p><p>Thus, when I&nbsp;have something to&nbsp;show (I&nbsp;hope to&nbsp;deliver a&nbsp;preliminary working version, though not yet feature-complete, within the upcoming week or so), I&nbsp;will probably brag about the design solutions I’ve taken. While I’m at it, I&nbsp;will possibly also write the long-delayed description of the new build system.</p><p>If there is anybody out there besides me who actually cares for that, stay tuned!</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-06-11:post:mind-the-symlinks</a:id> | |
| <a:title>Today’s lesson: Mind the symlinks</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/06/11/mind-the-symlinks/"/> | |
| <a:updated>2008-06-11T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Probably every day I&nbsp;keep learning new things, without even realizing it most of the time. The vast majority of them are minor or even tiny tidbits of knowledge; but even these might be worth noting down from time to&nbsp;time, especially when they are tiny pitfalls I’d fallen into and spent a&nbsp;couple of minutes getting out. By sharing them, I&nbsp;might hopefully prevent someone else for slipping and falling in.</p><p>So here’s a&nbsp;simple Unix question: If you enter a&nbsp;subdirectory of the current directory and back to&nbsp;<code>..</code>, where will you end up? The most obvious answer is, of course, “in the original directory”, and is mostly correct. But is it always? Let’s see.</p><pre><code class="nohighlight">nathell@breeze:&#126;$ pwd | |
| /home/nathell | |
| nathell@breeze:&#126;$ cd foobar | |
| nathell@breeze:&#126;/foobar$ cd .. | |
| nathell@breeze:&#126;$ pwd | |
| /home/nathell | |
| </code></pre><p>So the hypothesis seems to&nbsp;be right. But let’s try doing this in Python, just for the heck of it:</p><pre><code class="nohighlight">nathell@breeze:&#126;$ python | |
| Python 2.5.2 &#40;r252:60911, Apr 21 2008, 11:12:42&#41; | |
| &#91;GCC 4.2.3 &#40;Ubuntu 4.2.3-2ubuntu7&#41;&#93; on linux2 | |
| Type &quot;help&quot;, &quot;copyright&quot;, &quot;credits&quot; or &quot;license&quot; for more information. | |
| &gt;&gt;&gt; import os | |
| &gt;&gt;&gt; print os.getcwd&#40;&#41; | |
| /home/nathell | |
| &gt;&gt;&gt; os.chdir&#40;&quot;foobar&quot;&#41; | |
| &gt;&gt;&gt; os.chdir&#40;&quot;..&quot;&#41; | |
| &gt;&gt;&gt; print os.getcwd&#40;&#41; | |
| /var | |
| </code></pre><p>Whoa, hang on! What’s that <code>/var</code> doing there? Of course the one thing I&nbsp;didn’t tell you is that <code>foobar</code> is not really a&nbsp;directory, but rather a&nbsp;symlink pointing to&nbsp;one (<code>/var/log</code> in this case).</p><p>The corollary is that the shell builtin <code>cd</code> is <i>not the same</i> as Unix <code>chdir&#40;&#41;</code> (it is easily checked that both Perl and C exhibit the same behaviour). In fact, the shell builtin has an oft-forgotten command-line switch, <code>-P</code>, which causes it to&nbsp;follow physical instead of logical path structure.</p><p>On a&nbsp;closing note: I&nbsp;have somewhat neglected the blog throughout the previous month, but I&nbsp;hope to&nbsp;revive it soon. It is not unlikely that such irregularities will recur.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-05-19:post:recently-read-1</a:id> | |
| <a:title>Recently read #1: Akhmatova meets Bashō (Vasil Bykaŭ, “The Wall”)</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/05/19/recently-read-1/"/> | |
| <a:updated>2008-05-19T00:00:00Z</a:updated> | |
| <a:content type="html"><p>(Introductory note: This post marks the beginning of a&nbsp;new series on this blog, aptly titled “Recently read.” Every now and then I&nbsp;will try to&nbsp;verbalize afterthoughts inspired by the books I&nbsp;happen to&nbsp;read, and post them here. I&nbsp;hope these recommendations or anti-recommmendations might turn out to&nbsp;be useful for someone.)</p><blockquote><p> Give me<br> a kiss to build a dream on,<br> and my imagination<br> will thrive upon that kiss;<br> sweetheart,<br> I ask no more than this —<br> a kiss to build a dream on. </p></blockquote><p>Thusly starts the <a href='http://www.youtube.com/watch?v=e3PXiV95kwA'>Fallout 2 intro</a> — a&nbsp;mini-movie that can be considered a&nbsp;piece of art in its own right. Louis Armstrong sings these words in an abandoned underground cinema, wherein a&nbsp;movie is displayed, touching on nostalgia for pre-War times as well as severe dangers that lurk on the surface of the earth. And then come these words…</p><p><a href='http://www.youtube.com/watch?v=_mcJAI6oRYY'>“War, war never changes.”</a></p><p>Just like throughout the entire Fallout saga, these words reverberated in my mind as I&nbsp;read “The Wall,” a&nbsp;collection of short stories by Vasil Bykaŭ, the late Belarussian writer.</p><p>For the war indeed does not change. And wherever it appears, it carries around such an amount of destruction and utter wrongness that it is next to&nbsp;unimaginable for a&nbsp;generation grown up in a&nbsp;relatively peaceful place and time such as ours. In fact, even the words “utter wrongness” do&nbsp;not do&nbsp;justice to&nbsp;what was once an unescapable reality. There is only one way to&nbsp;find appropriate words: to&nbsp;show it, show it without overlooking anything, show it dryly and aloofly in all its hideousness.</p><p>And Bykaŭ does. There is not a&nbsp;single word of moralizing in these stories. There are no high words, and barely even a&nbsp;human thought beyond fear for life. There is pure depiction; and yet every word in this depiction stands firm and cannot be removed without losing the level of detail called for. This induces associations with Anna Akhmatova and her famous “Requiem,” which begins as follows:</p><blockquote><p> Это было, когда улыбался<br> только мертвый, спокойствию рад. </p></blockquote><p>“Это было.” “It happened.” These simple words are immensely powerful. And the same two words, unspoken, echo throughout the entire book. It happened, and it was like this. Nothing more can, or should, be told.</p><p>I’ve mentioned the level of detail; this aspect of these stories deserves longer comment. It is imminent that they would not be quite as powerful were it not for the detail. One can almost sense the chill of a&nbsp;dawn rising up above some godforsaken trench somewhere on the battlefront. Or shudder at the cold dampness of the soil inside it. Or smell the stench of decay rising above a&nbsp;corpse shot several days ago. Or feel the almost palpable fear floating in the crossfire of danger, one on the enemy side, the other shaped as one’s own commandment. Or the gloom with which a&nbsp;small group of soldiers sets out to&nbsp;dig their final resting place before committing suicide, lest worse fate befall them.</p><p>These stories are almost “haikuistic,” so to&nbsp;speak, in that each one of them resembles a&nbsp;very thinly cut and faithfully portrayed slice of reality from which there is no escape. This shows most strongly in case of the shortest ones, like “The Hill,” which are just several pages long, but it arguably holds even for the longest text in the book, the opening novella, “Love Me, Soldier.” (In which, by the way, Falloutesque associations are particularly strong: imagine a&nbsp;Belarussian sergeant who finds a&nbsp;fellow countrygirl hiding in a&nbsp;village in Austria, at the very end of the war, and falls in love with her. Doesn’t that sound like “a&nbsp;kiss to&nbsp;build a&nbsp;dream on?” Well, in Bykaŭ’s world, good dreams never come true.)</p><p>I&nbsp;quoted Akhmatova’s “it happened.” Yet, perhaps, the most striking and saddening impression from “The Wall” as a&nbsp;whole, and one that sets it apart from other war literature, is that this should really read “it still happens.” For the war has ended, but it takes long for a&nbsp;nation to&nbsp;recover from the scars it left; especially the Belarussian nation, who have been held captive by various regimes for too long and have never actually experienced freedom that we&nbsp;take for granted. Once a&nbsp;wound has been healed, it is all too easy to&nbsp;reopen it. And fear for speaking one’s own language remains the same, war or no war.</p><p>No wonder Bykaŭ’s writings are still censored in his homeland. Thanks to&nbsp;the Internet, though, <a href='http://kamunikat.org/4108.html'>the full Polish text</a> of all the stories is available online. Highly recommended.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-05-05:post:inward-ripeness</a:id> | |
| <a:title>Inward ripeness</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/05/05/inward-ripeness/"/> | |
| <a:updated>2008-05-05T00:00:00Z</a:updated> | |
| <a:content type="html"><blockquote><p> How soon hath Time, the subtle thief of youth,<br> Stol’n on his wing my three and twentieth year!<br> My hasting days fly on with full career,<br> But my late spring no bud or blossom shew’th.<br> Perhaps my semblance might deceive the truth<br> That I to manhood am arrived so near;<br> And inward ripeness doth much less appear,<br> That some more timely-happy spirits endu’th.<br> Yet be it less or more, or soon or slow,<br> It shall be still in strictest measure ev’n<br> To that same lot, however mean or high,<br> Toward which Time leads me, and the will of Heav’n:<br> &nbsp;&nbsp;All is, if I have grace to use it so,<br> &nbsp;&nbsp;As ever in my great Task-Master’s eye. </p></blockquote><p>John Milton is said to&nbsp;have composed this sonnet on his twenty-fourth birthday, and his thoughts (including, but not limited to, the criticism of the achievements so far) are very much in line with mine on my very own 24th birthday. One wonders what is the programming equivalent of “Paradise Lost.”</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-30:post:cl-netstrings</a:id> | |
| <a:title>cl-netstrings</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/30/cl-netstrings/"/> | |
| <a:updated>2008-04-30T00:00:00Z</a:updated> | |
| <a:content type="html"><p>I’ve just packaged up the Common Lisp netstring handling code that I&nbsp;<a href='http://blog.danieljanus.pl/hacking-away-with-json-rpc.html'>wrote a&nbsp;week ago</a> into a&nbsp;neat library. Unsurprisingly enough, it is called cl-netstrings and has its own <a href='http://github.com/nathell/cl-netstrings'>home on the Web</a>. It’s even asdf-installable! I&nbsp;wonder whether this one turns out to&nbsp;be useful for anybody besides me…</p><p>The other thing I’ve been working on is a&nbsp;new build system for Poliqarp. But that’s the story for another post — most probably I&nbsp;will write about it when it gets out of a&nbsp;state of constant flux.</p><p><i>Update 2010-Jan-17</i>: cl-netstrings is now hosted on GitHub; I’ve updated the link.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-25:post:best-os-ever</a:id> | |
| <a:title>Best OS ever</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/25/best-os-ever/"/> | |
| <a:updated>2008-04-25T00:00:00Z</a:updated> | |
| <a:content type="html"><p>If you are reading this on a&nbsp;box that does not have an impressive amount of RAM (say, 512 MB or less) and is running a&nbsp;fairly recent Linux, then for goodness sake, drop everything you are doing right now and follow the instructions in this entry. I’m going to&nbsp;show you how to&nbsp;make your system use the memory in a&nbsp;more efficient way, <i>yielding an effect almost equivalent to&nbsp;increasing its amount — with no expenses whatsoever!</i> Sounds good? Read on.</p><p>You see, there’s this Linux kernel module for kernels 2.6.17 and up (that’s what the phrase fairly recent in the previous paragraph macroexpands to), called <a href='http://code.google.com/p/compcache'>Compcache</a>. It works by slicing out a&nbsp;contiguous chunk of your RAM (25% by default, but it’s settable, of course) and setting it up as a&nbsp;swap space with highmost priority. The trick is that pages that are swapped out to&nbsp;this area are compressed using the <a href='http://www.oberhumer.com/opensource/lzo/'>LZO</a> algorithm, which provides very fast compression/decompression while maintaining a&nbsp;decent compression ratio. In this way, more unused pages can fit in memory, and less of them are swapped out to&nbsp;disk, which can considerably cut down disk swap usage. I’ve enabled it in my system and it doesn’t seem to&nbsp;cause any problems, while providing a&nbsp;visible efficiency boost. Here’s how I&nbsp;did it on a&nbsp;freshly-installed <a href='http://www.ubuntu.com/products/whatisubuntu/804features/'>Ubuntu Hardy</a>:</p><ul><li>I&nbsp;installed the Ubuntu package <code>build-essential</code>, then downloaded Compcache from its site, extracted it, entered its directory and compiled it by saying make. So far, so easy.</li><li>Unfortunately, one cannot say <code>make install</code> — creating a&nbsp;flexible cross-distro <code>install</code> target is admittedly hard. So I&nbsp;installed it by hand, ensuring that my system enables it automatically on boot-up.</li><li>I&nbsp;created a&nbsp;directory <code>/lib/modules/2.6.24-16-generic/ubuntu/compcache/</code> and copied the four kernel modules (<code>compcache.ko</code>, <code>lzo1x&#95;compress.ko</code>, <code>lzo1x&#95;decompress.ko</code>, and <code>tlsf.ko</code>) created by the compilation to&nbsp;that directory.</li><li>Next, I&nbsp;ran <code>depmod -a</code> to&nbsp;make the modules loadable by <code>modprobe</code>.</li><li>I&nbsp;edited the file <code>/etc/modules</code> and added a&nbsp;line at the end, containing the single word <code>compcache</code>.</li><li>I&nbsp;copied the shell scripts <code>use&#95;compcache.sh</code> and <code>unuse&#95;compcache.sh</code> that come with compcache to&nbsp;<code>/usr/local/bin</code>.</li><li>I&nbsp;created an executable script <code>/etc/init.d/compcache</code> with the following contents:<pre><code class="bash">#!/bin/sh | |
| case &quot;$1&quot; in | |
| start&#41; | |
| /usr/local/bin/use&#95;compcache.sh ;; | |
| stop&#41; | |
| /usr/local/bin/unuse&#95;compcache.sh ;; | |
| esac | |
| </code></pre></li><li>The last step was to&nbsp;create a&nbsp;symlink <code>/etc/rc2.d/S02compcache</code> pointing to&nbsp;that script.</li></ul><p>I&nbsp;then rebooted the system and verified that the new swapspace is in use:</p><pre><code class="bash">nathell@chamsin:&#126;$ cat /proc/swaps | |
| Filename Type Size Used Priority | |
| /dev/sdb2 partition 996020 0 -1 | |
| /dev/ramzswap0 partition 128896 111396 100 | |
| </code></pre><p>With the final release of Hardy installed on my main box and compcache optimizing its memory usage, I&nbsp;do&nbsp;not hesitate to&nbsp;call this combo the best OS I&nbsp;have ever had installed.</p><p>And no, I&nbsp;don’t own a&nbsp;Mac. :-/</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-24:post:hacking-away-with-json-rpc</a:id> | |
| <a:title>Hacking away with JSON-RPC</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/24/hacking-away-with-json-rpc/"/> | |
| <a:updated>2008-04-24T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Let’s try:</p><pre><code class="lisp">&#40;let &#40;&#40;s &#40;socket-stream | |
| &#40;socket-connect &quot;localhost&quot; 10081 | |
| :element-type '&#40;unsigned-byte 8&#41;&#41;&#41;&#41;&#41; | |
| &#40;write-netstring &quot;{\&quot;method\&quot;:\&quot;ping\&quot;,\&quot;params\&quot;:&#91;&#93;,\&quot;id\&quot;:1}&quot; s&#41; | |
| &#40;finish-output s&#41; | |
| &#40;princ &#40;read-netstring s&#41;&#41; | |
| &#40;close s&#41;&#41; | |
| ; { &quot;result&quot;: &quot;pong&quot; } | |
| ; --&gt; T | |
| </code></pre><p>Yay! This is Common Lisp talking to&nbsp;a&nbsp;<a href='http://json-rpc.org/'>JSON-RPC</a> server written in C. This means that I&nbsp;have now the foundations for rewriting Poliqarp on top of JSON-RPC (according to&nbsp;the <a href='http://blog.danieljanus.pl/poliqarp-new-protocol.html'>protocol spec</a> I&nbsp;have recently posted) up and running, and all that remains is to&nbsp;fill the remainder.</p><p>Well, to&nbsp;be honest, this is not exactly JSON-RPC. First off, as you might have noticed, the above snippet of code sends JSON-RPC requests as <a href='http://cr.yp.to/proto/netstrings.txt'>netstrings</a>. This is actually intentional, and the reasons for adopting this encoding have been described in detail in the spec (it basically boils down to&nbsp;the fact that it greatly simplifies reading from and writing to&nbsp;network, especially in C). I&nbsp;wrote some crude code to&nbsp;handle netstrings in CL — now it occurred to&nbsp;me that it might actually be worthwhile to&nbsp;polish it up a&nbsp;little, write some documentation and put on <a href='http://www.cliki.net/'>CLiki</a> as an asdf-installable library. I’ll probably get on to&nbsp;this quite soon.</p><p>Second, the resulting JSON object does not have all the necessary stuff. It contains the result, but not the error or id (as mandated by the <a href='http://json-rpc.org/wiki/specification'>JSON-RPC spec</a>). This is actually a&nbsp;deficiency of the <a href='http://www.big-llc.com/software.jsp'>JSON-RPC C library</a> I’m currently using. It places the burden of constructing objects that are proper JSON-RPC responses on the programmer, instead of doing that itself. This will be easy to&nbsp;sort out, however, because the library is small and adheres to&nbsp;the <a href='http://en.wikipedia.org/wiki/KISS_principle'>KISS principle</a>. More of a&nbsp;problem is that the licensing of that library is unclear; I&nbsp;emailed the maintainers to&nbsp;explain the status.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-24:post:forgetting</a:id> | |
| <a:title>Forgetting</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/24/forgetting/"/> | |
| <a:updated>2008-04-24T00:00:00Z</a:updated> | |
| <a:content type="html"><p>It has just occurred to&nbsp;me that the best way to&nbsp;throwing things out of one’s mind is to&nbsp;let it be absorbed by something else. I&nbsp;guess this is oft-overlooked fact, even though it seems to&nbsp;be quite obvious. In particular, forcing oneself not to&nbsp;think about something is <i>not</i> a&nbsp;wise strategy, since it leads to&nbsp;mental strain and thinking more and more, eventually yielding dejectedness that can be hard to&nbsp;get over.</p><p>And what could be more absorbing than debugging a&nbsp;<code>SIGSEGV</code> buried deeply in the innards of some library early in the morning? ;–)</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-22:post:eclm-2008</a:id> | |
| <a:title>ECLM 2008</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/22/eclm-2008/"/> | |
| <a:updated>2008-04-22T00:00:00Z</a:updated> | |
| <a:content type="html"><blockquote><p> <i>What is there left for me to do in this life</i>?<br> <i>Did I achieve what I had set in my sights?</i><br> <i>Am I a happy man, or is this sinking sand?</i><br> <i>Was it all worth it?—was it all worth it?</i><br> <p style="text-align: right;">— Queen</p> </p></blockquote><p>Gusts of moderate wind are blowing at my face through the open window of a&nbsp;train from Amsterdam to&nbsp;Warsaw as I&nbsp;write these words. The last buildings of Amsterdam have vanished a&nbsp;while ago, giving ground to&nbsp;the damp, low countryside of the Netherlands — not quite fascinating sight to&nbsp;be watching — so I&nbsp;decided to&nbsp;fire up my laptop and write down some impressions while they are sharp and vivid — impressions from the <a href='http://www.weitz.de/eclm2008/'>European Common Lisp Meeting</a> that was held in Amsterdam yesterday.</p><p>I&nbsp;was there with <a href='http://blog.pasternacki.net/'>Maciek</a> and <a href='http://lisp.jogger.pl/'>Richard</a>. Amsterdam did not receive us warmly, pouring some mild yet cold rain on us, but our hosts — Lispniks from the Hague, Gabriele and Victor from <a href='http://streamtech.nl/'>Streamtech</a> — turned out to&nbsp;be really nice guys. I’m not going to&nbsp;go into a&nbsp;very detailed description of the social aspects of our trip, instead focusing on the conference itself. And that is definitely a&nbsp;topic worth talking about for a&nbsp;long time.</p><p>The first man to&nbsp;speak was Jeremy Jones of <a href='http://www.clozure.com/'>Clozure Associates</a>, talking about InspireData and how they did it in Lisp. Although they also seem to&nbsp;be the people behind Clozure CL the implementation of Common Lisp, InspireData, the product their presentation was about, seems to&nbsp;have been written in LispWorks. It is a&nbsp;quite interesting application for browsing datasets in many interesting ways and draw conclusions for them. Jeremy started off with a&nbsp;demonstration presenting the key ideas of InspireData and what it can do, and this almost instantly hooked the attention of most of the gathered Lispers; mine, at least, definitely. First off, it seems to&nbsp;be quite a&nbsp;nice success story of a&nbsp;real-world application of Lisp, well worth learning about and mentioning where it deserves a&nbsp;mention. Second, one of its great features shown by the demo is that one can copy HTML tables from a&nbsp;Web browser and paste them as InspireData datasets. Given that Poliqarp now has statistical features and can export its data to&nbsp;HTML, I&nbsp;wonder whether it is possible to&nbsp;couple it with InspireData to&nbsp;interactively explore linguistic material in an absorbing way. That’s certainly a&nbsp;topic worthy of further research.</p><p>And last but not least, Jeremy outlined the points they did wrong and those they got right. Among those latter were two letters that now constitute a&nbsp;huge part of my professional life: <strong>QA</strong>. He just couldn’t emphasize enough how crucial the fact that they had a&nbsp;serious quality assurance process from the very beginning proved to&nbsp;yield the final quality of the product. That’s the lesson I’m now quickly learning. When I&nbsp;learned that InspireData was mostly tested by hand by a&nbsp;skilled QA team, I&nbsp;felt somewhat proud of being able to&nbsp;automate large parts of the process at Sentivision. I’m very curious where this path will lead me to. Let’s hope for the best!</p><p>The next speaker was Nicolas Neuss of University of Karlsruhe, talking about <a href='http://www.femlisp.org/'>Femlisp</a>, a&nbsp;framework for solving partial differential equations in Common Lisp. I&nbsp;have little to&nbsp;say about this one, since I&nbsp;lack the mathematical background needed to&nbsp;fully comprehend and appreciate the topic; it’s just not my kettle of fish. Undoubtedly, though, Femlisp seems to&nbsp;be filling its niche in a&nbsp;neat way, as the demonstrations showed.</p><p>After a&nbsp;coffee break, Stefan Richter came up with the one presentation that I’ve been looking forward to&nbsp;the most; that of using Common Lisp for large, scalable Internet systems. After all the talks were over, Maciek dubbed it a&nbsp;“very nice anti-FUD presentation” and I&nbsp;could not agree more. I&nbsp;didn’t learn many new things from it, but the author clearly knows how to&nbsp;attempt to&nbsp;convince non-Lispers to&nbsp;try out Lisp. The talk started off with outlining the typical designs of Web apps and portals, starting with simple one-server scenarios that don’t scale well and progressing in the direction of more scalable and extensible ones. Stefan then pointed out that in some mainstream languages like Java there exists a&nbsp;mature and proven infrastructure for employing such designs. And then came the key point — <i>that this is the case also for Common Lisp!</i> All the necessary tools are there, ready to&nbsp;use Right Now and free for the most part; they’re just not as mature in some cases. This is not much of a&nbsp;problem, though, given the incremental nature of Lisp development: any problem at hand is typically fixable much faster than in case of other languages. The only weird thing was that the author advocated using continuation-based Web frameworks (such as <a href='http://common-lisp.net/project/cl-weblocks/'>Weblocks</a> or <a href='http://common-lisp.net/project/ucw/'>UnCommon Web</a>) just a&nbsp;couple of minutes after discouraging using sticky sessions.</p><p>Next came Killian Sprotte with a&nbsp;speech about <a href='http://www2.siba.fi/PWGL/'>PWGL</a>, the program for computer-aided music composing. I&nbsp;have very mixed feelings about it. Notice that I&nbsp;didn’t use the word “presentation” — there was no presentation at all. Yes, that’s right. The speaker was just talking and showing off various things in the musical engine. Now, having no presentation accompanying the talk is not necessarily a&nbsp;bad thing in itself; but without one, it’s a&nbsp;little harder to&nbsp;draw attention of the audience and a&nbsp;whole lot easier to&nbsp;deliver a&nbsp;chaotic talk instead of a&nbsp;cleanly-structured and well-organized one. Such was the case with this speech. Some features were shown, but with a&nbsp;fair amount of obscurity and boredom thrown in, leaving me with a&nbsp;rather low overall impression.</p><p>As for PWGL itself, some of the ideas employed in it seem a&nbsp;bit peculiar (for want of a&nbsp;better word) to&nbsp;me. As befits a&nbsp;Lisp program, it is an extensible utility that actually allows users to&nbsp;program music just as one programs software. But the way that programming is done… well, think of a&nbsp;graphical editor for Lisp programs. An editor in which to&nbsp;write, say, a&nbsp;factorial function, you right-click an initially blank sheet, select <code>defun</code> from a&nbsp;pop-up with a&nbsp;complicated set of menus and submenus… and kaboom! up comes a&nbsp;box divided into several sub-boxes. They correspond to&nbsp;— what else they could? — the name of the function, list of arguments, and a&nbsp;body. You can draw boxes representing computations, drag them around and link them with arrows — this is supposed to&nbsp;build complicated expressions out of simpler ones. And there is a&nbsp;huge library of musical tools, all available for the convenience of a&nbsp;programmer. Or, should I&nbsp;say, a&nbsp;composer.</p><p>Sounds cool? Maybe — for a&nbsp;newbie. I&nbsp;can’t really say. As someone who has high experience with Lisp and programming in general, I&nbsp;can only speak for myself. And for me all this click-and-drag-programming seems to&nbsp;be an unnecessarily tedious, obscure and error-prone way of doing things. Stuff like score editors, chord editors or various transformations is admittedly cool, but for lower-level matters the kind of visualization PWGL offers (and it obviously has its rough edges) seems to&nbsp;get in the way rather than staying out of it. But perhaps that’s just me?</p><p>By the time the fourth talk ended, most Lispers were already hungry, so a&nbsp;lunch break followed. I&nbsp;talked to&nbsp;some guy (I&nbsp;don’t remember his name, alas) who’s working on porting Clozure CL to&nbsp;64-bit Windows. This is great news — when the port’s complete, it has high chances of becoming the free Common Lisp implementation of choice for many Windows Lisp hackers.</p><p>Juan José García-Ripoll then <a href='http://ecls.wiki.sourceforge.net/space/showimage/eclm2008.pdf'>talked</a> about <a href='http://ecls.sourceforge.net/'>ECL</a>, another CL implementation that is characterized by a&nbsp;fairly small memory and disk footprint, while still managing to&nbsp;achieve decent performance (via compilation to&nbsp;C) and good standard compliance. It was good to&nbsp;see that ECL is still quite alive and getting better and better with each release. Just for the heck of it, I&nbsp;attempted in the evening to&nbsp;reproduce the problem I&nbsp;had with ECL a&nbsp;while ago on a&nbsp;fresh CVS checkout. I&nbsp;managed to&nbsp;reproduce it (for the curious, it was an issue with ECL failing to&nbsp;build after having been <code>configure</code>d with the option <code>--disable-shared</code>). So I&nbsp;reported the bug to&nbsp;Juan, and he promised to&nbsp;look into it within the next days. And I&nbsp;must say that reporting bugs IRL to&nbsp;open source projects’ maintainers is a&nbsp;very nice experience. :-)</p><p>And then came a&nbsp;really big surprise, and I&nbsp;mean a&nbsp;<i>nice</i> surprise. It took the form of Kristofer Kvello of <a href='http://www.selvaag.no/'>Selvaag</a>, a&nbsp;Norwegian-based house-building company, and his presentation on <a href='http://www.selvaag.no/en/Companies/Selvaagbluethink/aboutus/Sider/default.aspx'>House Designer</a>, a&nbsp;Common Lisp program for aiding in designing residences, as the name suggests. Yet another example of a&nbsp;success story in an area CL can really excel at. Basically, what House Designer can do&nbsp;is that you give it a&nbsp;<i>sketch</i>, containing a&nbsp;rough description of the shape of a&nbsp;flat or residence and layout of rooms, and out comes a&nbsp;very detailed project with all sorts of bells and whistles: the program automatically figures out what the number of windows should be and where they should be located, the number and location of electric outlets, the optimal types of walls, layout of water installation and what not. It’s transfixing when you think of the sheer amount of tedious labour it automates, taking into account all of the professional knowledge about designing houses accumulated over years, some parts of which a&nbsp;human can easily omit. And it’s been Lisp all the lifetime of this project, and it’s Lisp all the way down (except for the GUI in Java)! Very, very impressive!</p><p>Marc Battyani’s talk about <a href='http://www.hpcplatform.com/'>programming FPGAs in Lisp</a> probably should not have been stacked so late in the programme. I&nbsp;mean, the topic seems to&nbsp;be quite interesting (though a&nbsp;bit low-level for my interests), but there was something about Marc’s way of talking and showing things that sent me off dozing almost instantaneously. I’d been a&nbsp;bit tired after the many hours of sitting and listening to&nbsp;speeches, especially after having woken up at six o’clock, and so I&nbsp;somewhat regret missing large parts of the talk. It’s nice to&nbsp;know, though, that it is possible to&nbsp;do&nbsp;such things with Lisp. Seems to&nbsp;have a&nbsp;high hack value, as in: “Why do&nbsp;it this way? Because we&nbsp;<i>can</i>!”</p><p>And what better end of a&nbsp;conference could one ask for than a&nbsp;rant by Kenny Tilton? If you have only encountered Kenny on the Usenet (some of the crème de la crème of his postings is <a href='http://www.pasternacki.net/en/ken-tilton-fortunes'>meticulously collected by Maciek</a>) and think he’s one heck of a&nbsp;freak, you definitely should listen to&nbsp;him live. Here was another talk without slides — just talking and demonstrating stuff — but this time, it was a&nbsp;totally different thing. Kenny sure knows how to&nbsp;attract the attention of the audience and how not to&nbsp;let it loose throughout an hour’s worth of talking. And he changes topics with mastery, using digressions to&nbsp;a&nbsp;great effect to&nbsp;avoid the boredom slipping in, caused by bragging about one thing all the time. There was <a href='http://smuglispweeny.blogspot.com/2008/02/cells-manifesto.html'>Cells</a> in that talk, there was <a href='http://www.theoryyalgebra.com/'>teaching of algebra</a>, and there was high-speed driving through the streets of New York. I&nbsp;only hope someone has recorded that to&nbsp;put it online.</p><p>So, this was it. There was much talk afterwards, there was much beer, there was much socializing, there was much rejoicing. I&nbsp;saw a&nbsp;real <a href='http://laptop.org/'>XO-1</a> and played with it for a&nbsp;while, and boy, isn’t it cute! And then we&nbsp;all came back. And here I&nbsp;am, sitting at my desk in Warsaw (it’s the next day already; I&nbsp;really wish my laptop had a&nbsp;better battery), finishing up this longish blog entry and asking myself: was this 50 euro well spent?</p><blockquote><p> <i>Yes, it was a worthwhile experience, hahhahahahahhaaaa!</i><br> (evil chuckle à la Kenny)<br> <i>It was worth it!</i> </p></blockquote></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-16:post:poliqarp-new-protocol</a:id> | |
| <a:title>Poliqarp’s new protocol</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/16/poliqarp-new-protocol/"/> | |
| <a:updated>2008-04-16T00:00:00Z</a:updated> | |
| <a:content type="html"><p>The first version of the document I’ve been writing about <a href='http://blog.danieljanus.pl/tex-hackery.html'>a&nbsp;couple of days ago</a> is now <a href='http://bach.ipipan.waw.pl/~nathell/new-protocol.pdf'>ready for public review</a>. I’ll be making an initial attempt at the implementation once I&nbsp;return from the <a href='http://weitz.de/eclm2008/'>European Common Lisp Meeting ‘08</a> and write a&nbsp;report.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-14:post:im-not-playing-this-stupid-game-anymore</a:id> | |
| <a:title>I’m not playing this stupid game anymore</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/14/im-not-playing-this-stupid-game-anymore/"/> | |
| <a:updated>2008-04-14T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Not until the next tournament, that is. My achievements in the 12th Scrabble Championship of Warsaw can be described as “mediocre” at best; four won, one drawn and seven lost games mean that my general rating will drop down by two points or so. Oh well. Everybody knows it’s a&nbsp;stupid game. ;-) At least I’ve managed to&nbsp;get a&nbsp;decent small score, with an average of 377 points per game.</p><p>Random resolutions for the indefinite future:</p><ol><li>Get a&nbsp;final draft of the C++09 standard when it’s ready and acquaint myself with it as closely as possible. I&nbsp;strongly dislike C++ (and I’m not alone in this — see the <a href='http://yosefk.com/c++fqa/'>Frequently Questioned Answers</a> about C++ for very detailed criticisms); however, I’ve long wanted to&nbsp;learn that language better just to&nbsp;know all the strengths and weaknesses of the enemy. The ideal moment for this will be when the new standard is out; this will give me the advantage of not having to&nbsp;unlearn the things changed by the standard, while staying on a&nbsp;cutting and competitive edge.</li><li>Get a&nbsp;copy of <a href='http://en.wikipedia.org/wiki/Federico_Garc%C3%ADa_Lorca'>Federico García Lorca</a>’s poems translated into Polish by Jerzy Ficowski. I&nbsp;have only a&nbsp;very vague knowledge of Lorca (just his Romance of the Spanish Civil Guard (<a href='http://www.poesia-inter.net/index214.htm'>Romance de la Guardia Civil Española</a>)), but I&nbsp;very much like what little I&nbsp;know.</li></ol></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-10:post:recipe-for-successful-presentation</a:id> | |
| <a:title>Recipe for a successful presentation</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/10/recipe-for-successful-presentation/"/> | |
| <a:updated>2008-04-10T00:00:00Z</a:updated> | |
| <a:content type="html"><p><a href='http://www.latex-project.org/'>LaTeX</a> + <a href='http://latex-beamer.sourceforge.net/'>Beamer</a> (for typesetting the presentation in a&nbsp;visually pleasant, clean, simple and consistent way) + <a href='http://impressive.sourceforge.net/'>KeyJNote</a> (for presenting it stylishly to&nbsp;the audience) = a&nbsp;recipe for success. In particular, KeyJNote, which I&nbsp;found only yesterday, seems to&nbsp;be a&nbsp;fine and tremendously useful piece of software, despite being very young. The only annoyance I&nbsp;have found in it is that it doesn’t respond to&nbsp;Alt-Tab when in fullscreen mode. On the typographical side, I&nbsp;used the <a href='http://www.cert.fr/dcsd/THESES/sbouveret/francais/LaTeX.html'>progressbar</a> Beamer theme and the <a href='http://www.nowacki.strefa.pl/torunska-e.html'>Torunian Antiqua</a> font, both to&nbsp;great effect.</p><p>While I’m at this topic, <a href='http://jan.rychter.com/'>Jan Rychter</a> has recently posted <a href='http://jan.rychter.com/blog/files/sztuka-prezentacji-03-2008.html'>a&nbsp;great guide to&nbsp;giving presentations</a>, especially short ones. I&nbsp;heartily recommend it to&nbsp;those of you who speak Polish (is there actually any non-Polish-speaking person reading this?)</p><p><i>Update 2010-Jan-17</i>: KeyJNote is now called <a href='http://impressive.sourceforge.net/'>Impressive</a>.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-07:post:ubuntu-postinstall</a:id> | |
| <a:title>Ubuntu post-installation tricks</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/07/ubuntu-postinstall/"/> | |
| <a:updated>2008-04-07T00:00:00Z</a:updated> | |
| <a:content type="html"><p>Yesterday, my level of frustration with my old operating system at work exceeded a&nbsp;critical point, and I&nbsp;installed a&nbsp;fresh daily build of the not-yet-released <a href='https://wiki.ubuntu.com/HardyHeron'>Ubuntu 8.04</a> in place of it. Then, in addition to&nbsp;usual post-installation chores like setting up mail, hardware, etc., I&nbsp;performed a&nbsp;couple of steps to&nbsp;make the system more pleasurable to&nbsp;use. Here’s what I&nbsp;did, just in case someone finds this useful.</p><ol><li>First, I&nbsp;tweaked the font rendering. This was one area that has long been a&nbsp;PITA for Linux users (at least for me, since 2000 or so), but as far as Ubuntu is concerned, they introduced a&nbsp;change to&nbsp;Freetype somewhere along the way between Feisty and Gutsy which, when set up properly, makes the font rendering on LCD displays far superior for me to&nbsp;that of, say, Windows XP, in particular at small font sizes. The way to&nbsp;enable it is to&nbsp;enable sub-pixel rendering, and set the hinting level to&nbsp;“slight.” This results in a&nbsp;rendering very close to&nbsp;what the author of <a href='http://www.antigrain.com/research/font_rasterization'>Texts Rasterization Exposures</a> managed to&nbsp;achieve.</li><li>I&nbsp;installed the package <code>msttcorefonts</code> to&nbsp;get Microsoft’s free-as-in-beer set of core TrueType fonts, including Times New Roman, Arial, Georgia, etc. There are very many sites out there on the Web that were designed with these fonts in mind, and this is one of the few areas Microsoft doesn’t completely suck at.</li><li>Next I&nbsp;enabled bitmap fonts. The way to&nbsp;do&nbsp;this is to&nbsp;become root, cd to&nbsp;<code>/etc/fonts/conf.d</code>, remove the symlink named <code>70-no-bitmaps.conf</code>, and make a&nbsp;symlink pointing to&nbsp;<code>/etc/fonts/conf.avail/70-yes-bitmaps.conf</code> instead. This would come in handy in the next step.</li><li>Which was installing my favourite console font. Unfortunately, it doesn’t come preinstalled with the Gnome-based Ubuntu, but it was no big deal. The font is named console8x16 and it comes with Kubuntu’s (and KDE’s) default terminal emulator, Konsole. So I&nbsp;downloaded <a href='http://packages.ubuntu.com/hardy/konsole'>an appropriate package</a> (manually, without the help of APT, because all I&nbsp;wanted was the font, not the package itself). I&nbsp;then installed Midnight Commander (which I&nbsp;use a&nbsp;lot, if only for its great vfs feature, which allows to&nbsp;access, inter alia, Debian/Ubuntu packages as if they were directories), grabbed the file <code>console8x16.pcf.gz</code>, installed it in <code>/usr/share/fonts/X11/misc</code>, changed to&nbsp;that directory, ran <code>mkfontdir</code> and <code>mkfontscale</code>, logged out and restarted the X server.</li></ol><p>The last step was to&nbsp;use this font for Emacs, too. So I&nbsp;installed Emacs, created the file <code>&#126;/.Xdefaults</code> containing the single line</p><pre><code class="nohighlight">Emacs&#42;font: -misc-console-medium-r-normal--16-160-72-72-c-80-iso10646-1 | |
| </code></pre><p>and ran <code>xrdb &#126;/.Xdefaults</code>.</p><p>Then I&nbsp;got round to&nbsp;configuring Emacs itself. But that’s a&nbsp;story for another post.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-07:post:yavp</a:id> | |
| <a:title>YAVP</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/07/yavp/"/> | |
| <a:updated>2008-04-07T00:00:00Z</a:updated> | |
| <a:content type="html"><pre><code class="nohighlight">Jezus, the high elven wizard, saved the world with his brave efforts and became a great ruler while saving himself 34 times. | |
| He scored 24999532 points and advanced to level 50. | |
| He survived for 0 years, 123 days, 0 hours, 11 minutes and 39 seconds &#40;176207 turns&#41;. | |
| Jezus visited 127 places. | |
| His strength score was modified by +26 during his career. | |
| His learning score was modified by +17 during his career. | |
| His willpower score was modified by +10 during his career. | |
| His dexterity score was modified by +7 during his career. | |
| His toughness score was modified by +25 during his career. | |
| His charisma score was modified by +9 during his career. | |
| His appearance score was modified by +6 during his career. | |
| His mana score was modified by +13 during his career. | |
| His perception score was modified by +15 during his career. | |
| He was unnaturally aged by 76 years. | |
| He was the champion of the arena. | |
| He was a member of the thieves guild. | |
| He made a little water dragon very happy. | |
| He defeated the arch enemy of a mighty karmic wyrm. | |
| He adhered to the principles of the Cat Lord and thus rose to great fame. | |
| He saved Khelavaster from certain death. | |
| He left the Drakalor Chain after completing his quest and became a great leader and famous hero. | |
| </code></pre><p>Yay! Now that I&nbsp;have finished ADOM for the first time ever, after something like six years of trying, I&nbsp;can finally get back to&nbsp;work with peace of mind. :-)</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-06:post:tex-hackery</a:id> | |
| <a:title>The TeX Hackery</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/06/tex-hackery/"/> | |
| <a:updated>2008-04-06T00:00:00Z</a:updated> | |
| <a:content type="html"><p>After a&nbsp;longish while of inactivity, I&nbsp;finally got around to&nbsp;finishing the draft spec of a&nbsp;next-generation protocol for <a href='http://poliqarp.sf.net/'>Poliqarp</a>, the be-all-end-all corpus concordance tool that I&nbsp;maintain. The spec is being written in LaTeX, and it has a&nbsp;number of subsections that describe particular methods of the protocol. Each one of those is further divided into sub-subsections that describe the method’s signature, purpose, syntax of request, syntax of response, and an optional example. I&nbsp;thought to&nbsp;write a&nbsp;couple of macros to&nbsp;help me separate the document’s logic from details of formatting, so that I&nbsp;could say:</p><pre><code class="latex">\synopsis/&#40;&#41; -&gt; {version : int; extensions : string&#42;}/ | |
| </code></pre><p>and have it expanded into:</p><pre><code class="latex">\paragraph{Synopsis} | |
| \verb/{version : int; extensions : string&#42;}/ | |
| </code></pre><p>Being a&nbsp;casual LaTeX user who hardly ever writes his own macros, I&nbsp;first thought to&nbsp;use LaTeX’s command-defining commands, <code>\newcommand</code> and <code>\renewcommand</code>. However, I&nbsp;quickly ran into the limitation that the argument of commands defined in such a&nbsp;way can only be delimited by curly braces, which I&nbsp;could not use because they might appear in the argument itself.</p><p>I&nbsp;googled around and found that this limitation can be overcome by using <code>\def</code> instead, which is not a&nbsp;LaTeX macro but rather an incantation of plain TeX, and allows to&nbsp;use arbitrary syntax for delimiting arguments. Having found that, my first shot was:</p><pre><code class="latex">\def\synopsis/#1/{\paragraph{Synopsis}\verb/#1/} | |
| </code></pre><p>which, obviously enough, turned out not to&nbsp;work, producing errors about <code>\verb</code> ended by an end-of-line.</p><p>“What the heck?” I&nbsp;thought, and resorted to&nbsp;Google again, this time searching for tex macros expanding to&nbsp;verb. This yielded an entry from some TeX FAQ, which basically states that the <code>\verb</code> is a&nbsp;“fragile” command, and as such it cannot appear in bodies of macros. Ook. So it can’t be done?</p><p>“But,” I&nbsp;thought, “TeX is such a&nbsp;flexible and powerful tool, there must be some way around this!” And, as it would turn out, there is. Yet more googling led me to&nbsp;<a href='http://groups.google.pl/group/comp.text.tex/browse_thread/thread/5bca05fb8865a9c2'>this thread</a> on comp.text.tex, where someone gives the following answer for a&nbsp;similar question:</p><pre><code class="latex">\def\term#{ % | |
| \afterassignment\Term \let\TErm= }% | |
| \edef\Term{\noexpand\verb \string}} | |
| </code></pre><p>Now this is overkill. Why in the world am I&nbsp;forced to&nbsp;stuff such incomprehensible hackery into my document just to&nbsp;perform a&nbsp;seemingly simple task?! Easy things should be easy — that’s one of the principles of good design.</p><p>Reluctantly, I&nbsp;copied it over, and attempted to&nbsp;adjust it to&nbsp;my needs. After a&nbsp;number of initial failed attempts, I&nbsp;thought that I&nbsp;might actually attempt to&nbsp;understand what all these <code>\afterassignment</code>’s, <code>\noexpand</code>’s and <code>\edef</code>’s are for, so I&nbsp;downloaded the <a href='http://www-cs-faculty.stanford.edu/~knuth/abcde.html'>TeXbook</a> and dived straight in.</p><p>I&nbsp;spent another fifteen minutes or so reading bits of it and trying to&nbsp;understand tokens, macros, when they are expanded and when merely carried over, etc. But a&nbsp;sparkle of thought made me replace the whole complicated thingy with a&nbsp;simple snippet that actually worked.</p><pre><code class="latex">\def\synopsis{\paragraph{Synopsis}\verb} | |
| </code></pre><p>That’s right. This superficially resembles a&nbsp;C preprocessor macro, and works because I&nbsp;was lucky enough to&nbsp;have <code>\verb</code> appear last in the definition, thus allowing the “arguments” of <code>\synopsis</code> to&nbsp;be specified just like arguments to&nbsp;<code>\verb</code> and fit at exactly right place. I’m almost certain that it does not always work this way, but for now it’ll suffice.</p><p>Oh well. TeX is undoubtedly a&nbsp;fine piece of software that provides splendid results if used right. But I&nbsp;can’t get over the impressions that there are a&nbsp;great deal more idiosyncracies like this in it than in, say, Common Lisp, even though the latter’s heritage tracks back to&nbsp;as early as 1958 and is a&nbsp;whopping twenty years longer than TeX’s. (On the side note, as it turns out, someone has already written <a href='http://www3.interscience.wiley.com/cgi-bin/abstract/98518913/ABSTRACT'>a&nbsp;Lisp-based preprocessor for TeX macros</a>. Gotta check it out someday.)</p><p>As for the TeXbook itself: it is a&nbsp;fine piece of documentation that I&nbsp;will definitely have to&nbsp;add to&nbsp;my must-read list, though it admittedly has a&nbsp;math-textbookish feel to&nbsp;it. First, however, I&nbsp;want to&nbsp;finish “Shaman’s Crossing” by Robin Hobb (which I&nbsp;will probably brag about in a&nbsp;separate post once I’m finished with it) and tackle Christian Queinnec’s “Lisp in Small Pieces”.</p></a:content> | |
| </a:entry> | |
| <a:entry> | |
| <a:id>tag:blog.danieljanus.pl,2008-04-04:post:introduction</a:id> | |
| <a:title>Introduction</a:title> | |
| <a:link href="http://blog.danieljanus.pl/2008/04/04/introduction/"/> | |
| <a:updated>2008-04-04T00:00:00Z</a:updated> | |
| <a:content type="html"><p>So, there. Inspired by the newly-started blogs of some of <a href='http://www.joemonster.org/blog/pietshaq'>my</a> <a href='http://jan.rychter.com/blog/'>acquaintances</a>, I&nbsp;had this thought that I&nbsp;might actually have a&nbsp;word or two on a&nbsp;number of subjects, and that it might even be worth sharing. And here I&nbsp;am, typing this introductory entry in my Emacs.</p><p>I&nbsp;guess the first thing one usually writes about in a&nbsp;blog is introducing himself to&nbsp;the public, so for those of you who have arrived here through some links on the Web and don’t know me, here goes. I&nbsp;am a&nbsp;23-year-old (soon to&nbsp;be 24, though) programmer geek, living in Warsaw, Poland. In 2006, I&nbsp;graduated from Warsaw University, where I&nbsp;majored in computer science, and am now working full-time as a&nbsp;senior software engineer at <a href='http://www.sentivision.com/'>Sentivision</a>. I&nbsp;have a&nbsp;<a href='http://danieljanus.pl/'>homepage</a> (currently in Polish only, though I&nbsp;probably will translate it to&nbsp;English some day). These days, I&nbsp;tend to&nbsp;use Common Lisp for most of my programming work, though I&nbsp;also occassionally use Python, Ruby, C, Perl, OCaml, Haskell, Java, and a&nbsp;handful of other languages.</p><p>This is going to&nbsp;be a&nbsp;blog about my personal interests. This means mostly programming, with a&nbsp;fair share of posts about books, poetry, Scrabble, music, biking, cats, and a&nbsp;bunch of other topics thrown in. The new entries will most likely be added irregularly, whenever I&nbsp;feel like sharing a&nbsp;thought. My mother tongue is Polish, but I&nbsp;will try to&nbsp;maintain this blog in English just to&nbsp;polish up my English writing skills (no pun intended) and for greater worldwide understandability.</p><p>As you might have noticed, there is no possibility of leaving comments. This is a&nbsp;side-effect of the fact that this blog is, technically, just a&nbsp;bunch of static HTML pages (automatically generated with Blosxom), and is in line with my idea of blog comments: I&nbsp;view them as a&nbsp;way of providing direct feedback to&nbsp;the author, not as a&nbsp;publically available message board with discussions having a&nbsp;heavy tendency to&nbsp;drift off topic. So, should you like to&nbsp;comment on some post, feel free to&nbsp;drop me an email; I’ll be happy to&nbsp;respond to&nbsp;interesting mails in the blog. I&nbsp;can be contacted at dj at danieljanus dot pl.</p><p><i>Update 2010-Jan-17</i>: Several things have changed —– in particular, Sentivision doesn’t exist anymore — but I&nbsp;haven’t done any editing in this post other than updating the links.</p></a:content> | |
| </a:entry> | |
| </a:feed> |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| * Trying 212.47.254.231... | |
| * TCP_NODELAY set | |
| * Connected to blog.danieljanus.pl (212.47.254.231) port 80 (#0) | |
| > GET /atom.xml HTTP/1.1 | |
| > Host: blog.danieljanus.pl | |
| > User-Agent: curl/7.64.1 | |
| > Accept: */* | |
| > | |
| < HTTP/1.1 200 OK | |
| < Server: nginx/1.4.6 (Ubuntu) | |
| < Date: Wed, 22 Jan 2020 06:52:23 GMT | |
| < Content-Type: text/xml | |
| < Content-Length: 249013 | |
| < Last-Modified: Tue, 21 Jan 2020 21:19:01 GMT | |
| < Connection: keep-alive | |
| < ETag: "5e276ac5-3ccb5" | |
| < Accept-Ranges: bytes | |
| < | |
| { [1152 bytes data] | |
| * Connection #0 to host blog.danieljanus.pl left intact | |
| * Closing connection 0 |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment