Forge - Slightly Magic. Really practical software for Magic beginners like me. You can assemble decks, use ready-made decks, get randomized decks - and then play them against an AI. The AI isn't the strongest, but hey, I'm far from that too. It's all in Java and actually runs on Windows, OSX, and Linux alike. Nice to give your own deck a test run, especially if you don't have Magic players nearby (or they don't feel like testing your crazy creation). Oh, and it's open source too.
java
heuermh/leap-motion-processing. Very interesting, because I can play with my LeapMotion controller using Processing - the overhead to get something done is much lower than going for native programs. Additionally, it is cross-platform.
mrzl/LeapMotionP5. And another Processing library for Leap Motion. This one seems to be more complete, with gestures and such. Worth checking out.
Getting Started with Android Studio | Android Developers. Oh, Google sees the light and offers an alternative to Eclipse as an IDE for Android programming. And then IntelliJ of all things, which I already work with. Nice!
Java 3D Engine | Learn Java Programming in 3D. Looks very interesting, especially because it has a close integration into an IDE (BlueJ) with a focus on learning to program. And meanwhile, you can also directly generate Android applications from it and, for example, build your own games or toys.
Pyjnius: Accessing Java classes from Python | Txzone. Very interesting side project of Kivy - with this you can quite easily integrate and use Java classes in Python without having to switch to Jython. It is based on Cython and JNI and integrates directly into native Python. Kivy is slowly becoming a real alternative for Android development that I should take a closer look at.
commonsguy/cwac-anddown. Another Markdown implementation - this one uses sundown internally and JNI and the NDK to have a fast implementation of Markdown on Android. Worked flawlessly for me with the Nexus.
Arduino - MacOSX. What fascinates me about Arduino: the simple interface of the IDE (which is just an enhanced Processing) and the pile of crazy projects around it, such as Digispark, a mini-board that can do less but is tiny and runs directly from the USB port. You can really think about things like water level sensors for plant irrigation or similar. With the prices for the mini-board, this becomes directly realistic.
myabc/markdownj I should check out, because JMD is somehow still a bit buggy and the developer is no longer doing anything with it. This is a port of the original Perl sources, so it heavily uses Regular Expressions, but that shouldn't really cause big problems with my UniversalBrain program structure, since I cache the HTML output. Maybe it behaves better than JMD. Although, of course, the question is whether it can be properly integrated as a library.
Cletus/jmd. Since PegDown doesn't run on Android because the underlying parser wants to generate a dynamic parser class, which is not allowed there, take a look at this. It should also be quite comprehensive and is based on the Markdown# project for C#.
mitmel/SimpleContentProvider. Looks like a simple ORM that automatically generates an Android Content Provider. This makes the creation much slimmer in code.
ActionBarSherlock - Home. For later use: this allows you to use the ActionBar in code even on older Android versions, it automatically uses a backport if no native ActionBar is available.
sirthias/pegdown. Interesting Markdown implementation in Java, based on a real parser and not the usual ad-hoc parsers or collections of regular expressions. Could be an interesting starting point for me, especially since it also comes as an Idea project and I should be able to integrate it quite easily.
mpeltonen/sbt-idea. Hmm, interesting - an sbt plugin with which you can generate Idea project structures. With this, you can then use the IDE at the points where you want to use it on the same project. For example, for remote debug integration, the IDE is quite nice.
OrmLite - Lightweight Object Relational Mapping ORM Java Package. Let's take a closer look, an ORM that can also be used in Android. Programming SQLite directly with SQLiteDatabaseHelper just isn't that much fun for me. It's a bit too low-level.
[[[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.
FAQ - Kotlin - Confluence. The fifty-third Java-killer language for the JVM, which also attacks Scala here (the usual argument "Scala is too complicated", which on first glance is indeed true - Scala has few central basic features, which are then provided with many features for the programmer by the standard library and the good DSL possibility at the surface of the actual language). The question remains what will come of it, but since JetBrains is behind it, it will at least have a good IDE (JetBrains builds IntelliJ and other JVM IDEs, including PyCharm and with AppCode the only current OSX Objective-C alternative to XCode). And hey, anyone who names their language after an island near St. Petersburg already has a head start with me.
Mixing it up: when F# meets C#. As you never program in a closed room, the connections between languages are quite important - and especially on platforms like .NET and JVM. The mappings of F# data types to C# data types and the use of these look quite interesting. Using C# data from F# is trivial, but the other way around there are some peculiarities. A similar situation exists with Scala and Java.
The plan for mods : The Word of Notch. This is how other game studios should handle mods. Don't sue the people who build on your game, but openly welcome them. Notch even releases the entire source code for mod developers.
Jess, the Rule Engine for the Java Platform. If you ever need a rules engine for Java, Jess is based on the core ideas of CLIPS, which has existed for quite some time now (around the mid-80s), but integrates into the Java world. An alternative would be Hamurabi, a rules engine written in Scala that features an integrated DSL with Scala language tools.
agronholm / jython-swingutils. No idea what I could do with it yet, but if the Java world ever becomes interesting, this could become an interesting GUI library (Swing for Jython).
sunng87/jip. I'm not currently doing much with Jython, but jip sounds very practical: it's an analog to pip, but for Java libraries. So a simple command-line tool that downloads the necessary jar files and puts them in the right place. Integrated with virtualenv. Much more pleasant for me than, for example, dealing with Maven or similar Java-usual infrastructure tools.
nathanmarz/cascalog - take a closer look, a marriage of Clojure and Hadoop for easier evaluation of large data sets. The interesting thing about Cascalog: it draws ideas from Datalog and forms a query language for Hadoop data sets in Clojure.
Enterprise Java Development Tools | SpringSource. I should take a closer look, as it was recently about J2EE and EJB alternatives, and this is one of the more well-known alternatives.
Threads are great, but not every problem is a nail
If you want to have a good laugh: Node JS and Server side Java Script. Here, someone from the Java camp complains that Node.JS really isn't to be taken seriously and then produces the best example why something like Node.JS (and many other alternatives for server programming) exists - because the Java code gets longer and longer with each step. And even after several iterations for an example that is quite simple to implement in Node.JS (or e.g. with gevent in Python), a few errors and gaps in the Java code are already mentioned in the first comments.
Don't get me wrong - Java has a lot of good solutions for programming with multiple threads in the standard library. Probably the largest selection of possibilities for programming with multiple threads of all currently available languages. But as so often in life: threads are not the answer to all questions of parallelization. Especially when it comes to high request load, the assessment in the comments that 20K threads are already very high is ridiculous - tell that to the programmers of Eve Online, where every ship in their virtual universe is modeled as a microthread.
Java is an interesting platform, precisely because it comes with many low-level libraries with which you can do very interesting things - and which are helpful to build reasonable high-level constructs on top of them. For example, in combination with languages like Clojure or Scala, the thread monster loses some of its terror. But sometimes the answer is not the thread, but asynchronous IO (both for disk access and network access) and the intensive use of coroutines or continuations.
Also, the incomprehension of Java programmers about the approach of solving the multi-core problem simply with several parallel processes and message-passing between them is quite strange in 2011 - after all, 2009 and 2010 were the revival years for Erlang (don't forget, the language has existed for much longer) and the central idea of Erlang is precisely to set network- and CPU-spanning message-passing as the standard in order to achieve very simple parallelizability and scalability.
Java programmers always remind me of the COBOL programmers of my early days, who in every language and every programming approach deliberately picked out the things that were solved differently in COBOL (and sometimes even perhaps a bit simpler) - but then fell flat on their faces when they had to solve real problems outside the COBOL comfort zone with them.
The best thing about Java is the JVM and thus a platform that makes the multi-paradigm and multi-language approaches possible with which you can then use the tools for problems that are appropriate for them. And even then, sometimes the answer is still Node.JS or another small, lean, asynchronous server. Because even with a large collection of various hammers, you will still get a screwdriver for the screw.
IKVM.NET Home Page provides a Java VM in .NET - you should even be able to do crazy things like running Scala 2.8 on .NET with it.
Kilim - stumbled upon this while browsing the Orc documentation, a microthread library for Java.
Oracle cooks up free and premium JVMs - and Oracle begins to try to cash in on Java. If it works, Java could soon be in a similar situation to .NET: the free implementations lag behind the scope of the commercial ones. What this means for alternative languages on the JVM remains to be seen - but it will certainly cause some problems. However, the JVM world is large enough and equipped with sufficient alternatives, and Oracle is not Microsoft. Therefore, this could all just be a storm in a teacup and at most affect the typical Oracle victims.
Links
rfc1437 | Content-type: matter-transport/sentient-life-form - Strong trends towards "throw away with archive and start from scratch" with slight options for "throw away, static archive and maybe shovel a part into the new platform if I find the time". The link shows where I'm currently playing around. Wordpress with a few small plugins and an nginx caching front.
Bitrot
I've been hit by this as well. My old blog software probably won't be able to survive unchanged. Old Python version (2.3), old (very old) Django (0.91), old PsycoPG driver (1.0), old PostgreSQL (7.4) and all of this on an old Debian (a wild mix of various versions with backports and custom programs and several failed upgrade attempts). Argh.
Well, I'm still torn between "rewrite" and "throw away". The latter has the charm that I won't have to carry all that junk around anymore. And honestly, nothing particularly interesting ever happened on my blog anyway. Maybe I can set up a wget mirror beforehand and dump the whole thing somewhere statically, as an archive.
Rewriting naturally has a lot of charm as well, but converting thousands of old entries (over 4000 articles and over 4000 links, plus almost 200 images) from 8 years (first entry on 3.11.2002) of blogging doesn't sound like fun. And presumably, thousands of the links are outdated and obsolete anyway.
No idea what I'll do, maybe I'll try to bring the Metaeule to the new box first, where I only have the problem that PHP4 is no longer in the Ubuntu repository for 10.04 and I therefore have to force the owl onto PHP5 (and that with code based on Wordpress 1.5 - I must really be crazy).
Or I try to install an ancient Debian with the packages used at the time - the box doesn't run in the front anyway, but behind other machines, so the hacking risk is rather low at this point. The Metaeule naturally also has a few thousand posts in the archive (only 8291, which is almost nothing), but if I can keep the old software running (some security patches have been applied over time, so it can actually continue to tinker along), I don't necessarily have to tackle it.
Somehow, the internet was also such a really bad idea ...
Twisted Orchestration Language in Launchpad - and someone has ported the Orc combinators to Python, using Twisted. However, I personally find Twisted rather disgusting to program, but if you like ...
Kilim - stumbled upon this while browsing the Orc documentation, a microthread library for Java.
Orc Language - haven't read anything about it yet, but it looks quite interesting. The core is Cor, a functional language without side effects, and Orc, which is built on top of it, is used for orchestrating services in distributed systems. The whole thing in a quite appealing, compact syntax on the JVM. One could certainly take a look at it as an alternative to Scala and Clojure, Java is integrated as an external service, which makes it quite easy to build distributed systems in which parts are implemented in Java. It reminds me in many points strongly of the ideas of Erlang (generally assume a distributed system, but still keep parts local for performance reasons), but I find the syntax much more pleasant. And with the JVM a much more widespread VM than Erlang's BEAM.
Interactive Fabrication » Beautiful Modeler - wow, that's incredibly cool.
Tornado Web Server Documentation - I really need to take a closer look at Tornado. For a side project, I've built a web service with web.py, which was shockingly simple (and dirty). Tornado is based on a very similar concept, throws Django-like templates into the mix and offers a good asynchronous server and support for asynchronous sockets and http requests right away. Could be a good alternative for web services that need few resources.
Fat Cat Software - iPhoto Library Manager - since I was stupid enough to make a photobook on a different Mac than usual (well, the usual one was always occupied), I'll probably have to take a look at this to see if I can merge my books onto a single machine. It's quite annoying that Apple doesn't offer any merge function in iPhoto. With a notebook and a desktop, you quickly end up with separate libraries. If Lightroom supported book printing, I would have been gone from iPhoto a long time ago. Everything is somehow not quite satisfying.
The V4Z80P – A Z80 Based Laptop @ Retroleum - here someone not only builds his own computer with his own system, it's also a laptop. Or something similar anyway.
Oracle cooks up free and premium JVMs - and Oracle begins to try to cash in on Java. If it works, Java could soon be in a similar situation as .NET: the free implementations lag behind the scope of the commercial ones. What this means for alternative languages on the JVM remains to be seen - but it will certainly cause some problems. However, the JVM world is large enough and equipped with enough alternatives, and Oracle is not Microsoft. Therefore, this could all just be a storm in a teacup and only affect the typical Oracle victims.
Kunsthalle Bielefeld: Der Westfälische Expressionismus - I think I actually have a reason to drive to Bielefeld.
Mediathek für Mac OS X - I need to check this out. After all, archiving is now the viewers' job thanks to stupid private broadcasters (and politicians who have made themselves their errand boys).
Panasonic DMC-GF2 Preview: 1. Introduction: Digital Photography Review - I hate you, Panasonic. Now I want the cute little GF2+14mm kit. Menno. First Apple with the MacBook Air and now Panasonic, everyone just wants my money.
Eventlet Networking Library - I need to take a closer look at this, the monkey-patching of standard libraries to make them trivial to use in an asynchronous environment looks very interesting.
lambdaj - brings Java anonymous functions and higher-order functions (well, at least approximations of these).
JEmacs - the Java/Scheme-based Emacs - just for future curiosity blogged.
About Greenfoot - a graphical programming environment for games and other interactive content in Java. By the BlueJ creators.
Front Range Pythoneering: Realizing Jython 2.5 - it's written further down there. Jython has a GIL as a funny Easter egg in the future module (which makes future language features available as "Beta"). So no GIL, just a joke. I would have been quite surprised otherwise.
maven-jython-plugin - Maven Jython Plugin - hmm, the Jython support for Maven is quite outdated - the artifact only targets 2.2.1 and the plugin only goes up to 2.2.1. It seems like an update is urgently needed.
fastutil - sometimes certainly quite practical, Collections for Java that are based on primitive types and implement these Collections in a space- and performance-efficient manner. So for example something like an array of bytes. Or a map of strings to booleans. The library has over 1000 such combinations ready ...
Java Image Processing - Blurring for Beginners - A thousand and one ways to blur an image (which can indeed have practical uses) with Java code examples.
Nailgun: Insanely Fast Java - if the JVM start takes too long, Nailgun can help with a persistent JVM. It simply keeps running and is told what to do. Should therefore also help with Scala and Clojure, especially when you want to build small tools that don't want to start a new JVM every time.
ProGuard - helps with trimming down standalone jars. Although this is not so easy with Clojure or Scala standalone jars, it seems you need to tinker a bit.
SQLiteJDBC - another JDBC driver for SQLite
SQLiteJDBC - because I am a SQLite fan (if it's too complex for simple text files, SQLite is the next level), and because I play around with Scala and Clojure, I might need this here.
neo4j open source nosql graph database - the graph database for Java mentioned earlier. Looks quite interesting for situations where relational databases are too rigid and inflexible.
Maven - Guide to using proxies - because I needed it just now, as Leiningen (a build tool for Clojure) relies on Maven. Unfortunately, this has to be changed in an XML file, which makes it not so easy to automate. I need to come up with something useful for Linux that automatically switches various configs when settings change.
Yeti programming language - I should take a look at that, an ML for the JVM. Scala offers many of these features as well and certainly has much more momentum at the moment. But I've always found ML quite interesting because the language is quite compact - and with JVM integration, you get all the Java libraries to play with so to speak for free. Although Yeti is really only an ML-style language, not really ML (significant differences in syntax).
Hudson CI - since I am increasingly dealing with JVM languages, something like this would be quite interesting. A Continuous Integration platform in and for Java (and also usable for other purposes). Interesting, especially the easy installation - just a .war file that you start or throw into a container and then configure via the web interface. Continuous Integration greatly helps with deployment, especially when you build your projects cleanly with unit tests. Manual execution of the test suite is then largely eliminated, as the CI server takes over and can, for example, automatically deploy cleanly running builds as beta or provide working snapshots (in the sense of the test cases working) as downloads.
Play framework - a rather interesting framework for Java in the style of Django or Rails. In the dev version 1.1, it also supports Scala for the view functions, which is quite interesting, because no matter how nice the framework is, I won't subject myself to raw Java.
NetBeans support for Google App Engine - the title says it all. I quite like NetBeans, by the way. It looks quite bare (not particularly well integrated into Cocoa - Eclipse makes a much better visual impression), but unlike the alternatives, the plugins seem to work quite well (Eclipse produces strange errors, IntelliJ requires you to find the right version of the plugin for the right version of the IDE). And the Clojure plugin for NetBeans seems to be the nicest so far - the REPL is really good.
:: Clojure and Markdown (and Javascript and Java and...) - interesting post, because here the advantage of mixed languages on the JVM is fully utilized. Instead of writing a Markdown parser for Clojure, one in JavaScript is simply used via Rhino (JS in Java). Which also ensures that both the web client and the blog server can use the same implementation of Markdown.
for post in leo.blog():: Django-Jython 1.0.0 released! - not unimportant for a project at work: Django-Jython is finished. And included is the Oracle client, which we would also urgently need for the project. Nice.
avodonosov's abcl-idea - as I'm currently playing around with IntelliJ (and the plugins for Scala and Clojure for it), there's also a plugin for integrating Common Lisp into Idea. Even with the possibility of writing extensions for Idea in Common Lisp (and having your own REPL for it). I should definitely try it out.
(Field) - found at Schockwellenreiter and wow, this thing looks very interesting. Processing on steroids? In any case, much more open when it comes to programming languages. I definitely have to take a closer look, because simple graphical interfaces like Processing are what I'm missing for Processing or Abcl, for example.