programmierung - 16.2.2012 - 9.5.2012

Clojure/core — Reducers - A Library and Model for Collection Processing. Why a new library? Because the standard functions are interesting and meaningful, but sometimes you need a stricter implementation that avoids intermediate temporary collections and provides direct out-of-the-box support for parallelization. Without much fuss and bother, just a different namespace.

A free book (that will also be available as dead tree or electronic wood from O'Reilly) about backbone.js. Backbone.js provides an MVC-inspired structure for JavaScript programming (where you can argue a lot about what exactly is the View and the Controller and whether it is "pure" MVC - or you just program and ignore the theoretical ballast).

PyPy Status Blog: STM update: back to threads?. The discussion and development continue to progress - and the discussion is returning to the old thread model, only expanded with a function to define atomic blocks of code. And all of this in such a way that the code would even run under normal CPython (though then of course without the advantages of STM, since there is no STM in CPython, there is still the GIL) but still makes sense to use multicore architectures. I like it more and more and I hope it will soon land in the PyPy Main Branch.

tuupola/jquery_lazyload. This might be interesting for displaying large amounts of images because it allows you to delay the loading of images until the user actually scrolls to them. The page is pre-built with placeholder images, and only the images are later sent over the line. However, I think Infinite Scroll is the better solution, as it allows not only images but also general content to be added - and it also works smoothly with Masonry so that these content blocks can also be visually well distributed.

dirq 1.1.2 documentation. Hey, I was recently looking for something like this - a queue based on the file system. The advantage: simplest persistence and good "debugging" by simply poking around in the file system. The disadvantage is that queues often need to perform some operations atomically - and this can become a bit tricky if you want to get it right. This is a port of an already existing Perl module, so the chances that most of the childhood diseases are out are quite high. The API, in any case, looks nicely simple. Definitely worth a closer look.

Hotcanvas: Realtime coding. I'm a fan of Processing-like environments, this one comes quite close, but runs as an interactive environment and looks quite nice. Ok, there are probably quite a few of these things by now, but still, I like this kind of stuff.

Bilderarchiv | rfc1437. My image archive was revised over the weekend and now comes with funny JavaScript gadgets for automatic tiling. Not really groundbreaking, but more interesting than the previous, rather boring format. jQuery Masonry is the main part of the work. Nice little JavaScript library. The most interesting part is probably the heuristic in my little plugin, with which I bring the images into portrait/landscape/square formats, so that the whole thing does not become too boring due to an excess of landscape formats. Unfortunately, there are still gaps in the image stream, where Masonry could actually become a bit smarter (and e.g. pull up small squares). Or I have to sit down again with the heuristic and make sure that the chances of gaps are reduced.

RubyMotion - Ruby for iOS. Since MacRuby already interests me, this sounds good too - directly programming for iOS in Ruby. However, there is no free version, which somewhat limits the trying out. Additionally, there is nothing in an IDE, it's pure command line. Which can be an advantage, but for debugging, for example, it's a real disadvantage.

Mojolicious - Perl real-time web framework. You had one problem, you took Perl. Now you have two problems and a bunch of sharp brackets to cut yourself on. Jokes aside: nice to see that Perl is not only still active, but also actively modern in the web environment. After all, Perl once set the standard in that area.

RavenDB - 2nd generation document database. Bookmarked because I want to check it out in the not-too-distant future. Sounds quite interesting from the features and might be useful for one or two projects that I am currently thinking about.

JSIL - .NET to JavaScript compiler. No idea if I already had this, but it's one of those crazy projects you can safely link twice. The actual .NET IL code is translated - so you can run programs in the browser that were not really intended for it. For example, part of XNA is supposed to run, so you can run games in the browser that are actually for the XBox.

the { buckblogs :here }: Maze Generation: Ellers Algorithm. Maze algorithms have fascinated me since my youth, but this one was new to me. It generates perfect mazes line by line, without trackback or recursion, with a runtime linearly dependent on the size of the maze. Pretty brilliant stuff.

jQuery Masonry. Alternative to BlocksIt. Worth checking out. Even pushes blocks more aggressively, rearranges the order if necessary.

BlocksIt.js - Dynamic Grid Layout jQuery Plugin. That's what it says. Sounds quite interesting, I have to check it out.

Kronuz/SublimeCodeIntel. CodeIntel is a port of the Komodo Code Intelligence to SublimeText2. With this, you can almost refer to ST2 as an IDE.

Cubism.js. So many projects, so little time. But just a quick blog note, if I ever have to deal with time series visualization in the near future, this looks really good for that.

jlongster/dcpu-lisp. Why this is cool? Well, Notch is working on a new game - something like Elite with integrated hacking. And the hacking happens on a 16-bit CPU that is based on a 6502. And now all kinds of people are building code for this CPU. Among other things, here is a Lisp compiler.

Subrepository - Mercurial. Quite embarrassing, what one keeps discovering and realizing that one should have been using it for a long time, but doesn't. Especially the tip with the "shallow main repository" sounds good, that could simplify some of the organizations of my projects. So far, I have rejected subrepositories precisely because of the fixed connection of the large main project with the library projects, since I use completely different external branches (i.e., repositories) for different environments and, for example, do not want to push my dependencies from the maintenance environment into production. With a shallow main repository per environment, on the other hand, I could cleanly separate the relationships and still document at a central point how the dependencies of the various repositories are represented. And yes, all of this here is just a note for myself, if you don't understand it, just ignore it, colorful pictures will definitely come again soon.

pycounters. I need to check this out, it allows you to easily integrate counters into a project that provide data on things like function calls or similar - basically something like the Windows Performance Counters, but for Python projects.

Virtualenv-clone 0.2.2 : Python Package Index. Not yet tried, but according to the description it copies virtualenv environments and fixes import paths, egg files, .pth contents and scripts. And it should work more completely than relocatable virtualenvs.

Introducing Pivot.js. Hmm, definitely worth a look, Pivot looks quite nice, simple API and interesting possibilities. I have a project at work that could really use some reporting features. And offloading to the client is sometimes a quite good idea.

The unbearable finality of pixel space. I tried the linked archiving tool for Flickr once and it works really well. I can even forgive the PHP for that. I have also occasionally pushed Flickr images into this blog (the "Neulich auf Flickr" posts), but the advantage of this backup script is that the structure and even the Flickr access rights are preserved. Unfortunately, albums and sets are not yet backed up, only the photostream. And the layout is very spartan. But maybe this would be a candidate to play with Bootstrap 2.0 and spice up the whole thing a bit.

flatiron/plates. An interesting JavaScript templating engine that takes a slightly different approach than many others - there is no separate template language, only HTML and JavaScript. Any logic is in the JavaScript and any structure is in the HTML and both are quite strongly separated. Instead of a template language, there are functions for precisely specifying which elements in the HTML should be changed how.

RQ: Documentation. Hmm, python-job-queue based on Redis with a rather simple interface. Could be an interesting alternative to Celery.

iphone - What happens to JavaScript code after app is compiled using Titanium Mobile - Stack Overflow. I was also interested in the question, so I blogmarked it here. Quite interesting what happens there, it goes much further than what PhoneGap does, for example.

Titanium Desktop – Node.js Prototype « Appcelerator Developer Center. Titanium is already on the list of things to test because, alongside PhoneGap, it is one of the ways to turn JS+HTML code into apps and desktop applications. And here, one of the developers shows how to integrate a node server into the desktop. This would also be quite interesting, although it probably won't work with iOS and Android (since there you are forced to use the JS engine provided by the system in the browser widget if you want to load dynamic code from outside).

Embedding and running Node.js within a Firefox XUL extension. Impressive what you can do with Firefox and its infrastructure. Theoretically, you could also modify this extension so that it runs in a single-site browser, which then directly opens the homepage of the embedded server, allowing you to build completely autonomous desktop applications in JavaScript (and for those wondering why I'm collecting all these JS-on-desktop things: with the help of Phonegap and some glue, you could not only build apps for iOS and Android, but also desktop applications with the same code).

NodObjC. I'm not sure if I really want this, but with this library you can bridge ObjC frameworks with JavaScript. This could be interesting, for example, in the context of PhoneGap, if you need to access iOS native APIs that are not yet provided by PhoneGap (though you need Node.js as a basis, I don't know if that already works on iOS).

topcube. I should take a closer look at this - a desktop app that includes an embedded web server (node.js) and browser (GTKWebKit). With this, you can build desktop applications based on JavaScript and Node.js - for example, also rebuild Amber Smalltalk into a compact desktop application. Unfortunately, the OSX support is still somewhat limited.

haypo/pysandbox. Something to look at again: a sandbox for Python scripts. According to the project description, it's not necessarily a security solution but rather just a simple protection for the Python process. Thus, it would at least be usable as a simple safeguard for a main process against errors in extension scripts.

BOO - Getting Started. After a long time, I took another look at Boo and I like what's happening there. Still very strongly based on Python in terms of syntax, but semantically quite different - for example, real macros in various variations, so that there is really an extended syntax. Or also the optionally available Duck Typing - a variant that I particularly like, because Boo combines static typing, type inference and Duck Typing in a way that really keeps all options open for the programmer. Then there's the good integration with .Net and C# assemblies. I think I need to play around with it a bit more, because as a prototyping language it could be quite practical - and at the moment I tend to use Mono more as a runtime, primarily because of the JIT implementations available there (and with Mono also AOT compilation, where it is needed).

Clojure-Py. I can't quite say what I think about it yet, but someone is building Clojure (the language) with Python and PyPy as the target platform. Basically, this is certainly an interesting idea, as the LLVM-based JIT implementation of PyPy can also compile other things. And since I am a fan of both Python and Lisa, something like this has to pique my curiosity. The language scope of Clojure is not yet fully represented, but that can still come.

Create a package for IOS — Kivy 1.1.2-dev documentation. Kivy - a GUI framework for Python - now also offers a way to package the application for iOS and, for example, run it on an iPad. No idea if it will actually be accepted in the AppStore, but the developers have already managed to get a program based on it in there, so the chances are good.

wbond/sublime_package_control. This is quite interesting - it seems like an ecosystem around Sublime Text 2 is slowly being built, similar to vim or TextMate. This will make the integration of extensions easier in the long run.

JulianEberius/SublimeRope. Very interesting - an integration of Python Rope (a refactoring library for Python code, written in Python) into Sublime Text 2. This will then provide refactorings directly in ST2 - one of the features I have learned to love in PyCharm (especially syntactically correct rename and extract method) and which were previously missing in ST2. I should probably take a look at it, although for projects where I need refactoring, I tend to go straight to PyCharm, simply because many other things come with it (e.g., the integrated debugger). Lately, I tend to switch between editors for simple things and IDEs for large projects, even if you then have to learn different operations - the use cases are just too different to handle with just one tool.

HyperCard, Visual Basic and the Importance of the Novice Developer. Interesting article that puts HyperCard in relation to Handheld Developer. And after playing around with Handheld Developer, I would say they are not completely wrong - it is a nice visual environment for creating iOS web applications with integrated hosting with which you can quickly put together a prototype and even get server-side scripting in JavaScript. Ok, it is not quite cheap, but there is a test version to see if you could have fun with it. The applications are actually not so fixed on iOS, because in principle it is just HTML5 and JavaScript - and should therefore also work with Androids (I have not tried that yet).

mtravers/heroku-buildpack-cl. And yet another Lisp link - here someone has relied on Heroku's buildpack-capable stack and built a buildpack for Clozure CL, so that you can also put Common Lisp in the cloud through it. Although this then has less similarity with Google App Engine, but rather with something similar to Amazon EC2.

Heroku | Clojure on Heroku. And even more Lisp. With Clojure, you can now also work on Heroku, the cloud platform. This might be an alternative to, for example, Google App Engine (on whose Java incarnation Clojure also runs).

Deep down inside, I'm still a Lisp fan. That's why the ecl-iphone-builder by Terje Norderhaug is very interesting to me - with it, you can compile a version of Embeddable Common Lisp for the iPhone or iPad and then deploy it to an iOS device via Xcode, start a Swank server there, and then connect remotely - and then play around or program with Lisp on the iPhone. Ok, the binding to the OSX APIs is still a bit brittle.

Room 101: The Miracle of become:. One of the corners where Smalltalk clearly differs from all other languages I have had to do with so far (except Common Lisp, but that's different, because everything is possible there), is the become: method, with which two objects in the running system exchange their identity - so that after the call all references to a after a become: b then refer to b and vice versa. This explains what this means in practice.

[[[New App]] Impressive: AIDE Is An IDE That Lets You Write And Compile Android Apps On Your Android Device, Begs For The Yo Dawg Treatment](http://www.androidpolice.com/2012/03/06/android-gets-a-native-ide-lets-you-write-android-apps-on-your-android-tablet-is-begging-for-the-yo-dawg-treatment/). Android development on Android devices (preferably tablets). That is so meta.

Vagrant - Virtualized development for the masses.. Looks good, you can quickly set up a development environment based on BSD or Linux via the command line - and then work with it without having to manually install a bunch of things. Basically appliance templates that can be installed via command line tool. And a whole range of systems are offered as hosts (including OSX, for example). So, for example, also a very easy way to set up a LAMP stack or something similar under OSX.

PySide for Android thp.io. That sounds very interesting - this way I would have a much more favorable programming language at my disposal to build Android programs. However, the start time of Activities written in Python might be quite significant due to the loading times of the Python stack and the Qt libraries. But for building a few small tools for personal use, that shouldn't matter.

pyprocessing - A Processing-like environment for doing graphics with Python - Google Project Hosting. Processing, for Python. It's already in the title.

Temporal Keys, Part 2 | Experimental Thoughts. One always learns new things about PostgreSQL - this time PERIOD, a data type that encompasses time spans, and EXCLUDES, another form of constraint on tables, with which overlaps of time periods can be avoided in the data design together with PERIOD. In Dynamics AX, there is something similar in the form of Date Effectivity, which goes a bit further because it also includes automatic creation of new areas, gap-free timelines, etc., while this is only the basics for non-overlapping data records. On the other hand, this can be used much more broadly, as you can formulate any EXCLUDES constraints.

ResponsiveSlides.js · Responsive jQuery slideshow. I am a fan of Bin and Lightbox, but I also like this small library at first glance - it is simple and easy to use and does not do a thousand things at once, but simply shows images in a slideshow. Specifically for animating header graphics, for example, this could be quite interesting.

The Julia Manual. Hmm, not yet sure what to think of this language, but it does sound interesting - a kind of Matlab, but based on LLVM and linguistically significantly renovated, with some interesting ideas (e.g., Julia expressions are stored internally in a Julia-specific data structure, so that real macros can be implemented).

Mac Developer Tips » How to Uninstall Xcode. There is also an official way to get rid of XCode. Just linking to it, because unfortunately XCode can dynamically load what you need from the internet, but not get rid of it - for this you are allowed to delete the XCode stuff and then reinstall it (smaller). Just the iOS stuff alone takes up 6G, so you can save a lot if you don't plan to program the iPhone.

Xcode, GCC, and Homebrew. Looks good - Apple provides a bare-bones GCC package with all frameworks, so you no longer need to load the monster installer from the AppStore, but can make do with a 170 MB package and still use Homebrew to compile open source OSX programs (at least as long as they don't use explicit XCode features). Especially if your own programming takes place in other IDEs and with other languages, it's quite nice to be able to do without the 8 GB that an installed XCode occupies. I'm seriously considering whether I should also give my Air this slimming cure.

stochastic-technologies/goatfish - GitHub. Looks interesting, a small Python module that uses SQLite as a persistence layer for arbitrary objects. Not at the level of an ORM, but rather at the level of a more complex key-value store. Quite interesting for the usual small hacks where you need object persistence quickly, but due to the simple structures, you don't see much sense in a developed data modeling - or if you don't know yet how the structures will look like during prototyping.