Blaze — Blaze 0.1-dev documentation. Hmm, I could have sworn I already had that, but never mind. Blaze is essentially a compiler that transforms numpy-like code and passes it to runtimes for evaluation. Specifically, it also supports many parallel runtimes and parallelization of evaluations. The data types are also significantly more developed than in numpy - the authors themselves consider Blaze to be the natural evolution of numpy. What fascinates me about it is the integration of a quite extensively developed array programming library into Python - since I've been playing around with J, I find array languages fascinating.
Archive December 2012
IOIO for Android - SparkFun Electronics. Also an interesting project, a friend pointed me to it today: an IO board for Android smartphones. It simply plugs in via USB and is accessed through a simple Java library. It has various analog and digital inputs and outputs, I2C and other goodies. You can even get a Bluetooth kit for it if you don't want to communicate via radio. Pricier perhaps than what you're used to in the Arduino environment, but still, sounds cool. I'll wait for my Smartduino first, though, which also has Android support.
Run Mobile Apps on Mac with BlueStacks :: Mobile Apps on Mac :: Mobile App Player for Mac | BlueStacks. Hey, the beta can now run any Android apps. I should definitely check it out. So one or the other Android tool would also be practical on the desktop, especially if there are not really good desktop versions available.
MariaMole | dalpix.com. If the normal Arduino IDE is too simple for you (although I would say that the simplicity is the great bonus), you can check out this project. This is a rather classic IDE with which you can build Arduino programs.
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.
several methods to find interesting areas of an image - and for example interesting for overview galleries where images are brought into fixed formats jd where you want to apply more intelligent cropping and scaling.
imwilsonxu/fbone · GitHub. Not so uncool at all. I'm actually a Djangonaut, but Flask has always interested me a bit, as it's quite a good basis for more compact projects. With the integration of HTML5 Boilerplate and CSS Bootstrap, this could also be interesting for small web projects with frontend. Although Flask offers enough room to grow to realize larger things - it's just that for larger things I often still reach for Django. But especially for the typical web service with additional HTML presentation of the data, this can really be practical.
Cubes 0.10.1 Released – Multiple Hierarchies Data Brewery. I think I've mentioned this before, but hey, TV repeats things all the time. And it looks even better, what you can do with it. I really need to take a closer look, there's a project where I think I could use it. I need to check how to integrate it, though, because my project uses Django and its ORM, and Cubes uses SQLAlchemy. It could be interesting to mix them.
The Ruggeduino. Might be interesting when I actually fry my upcoming toys ... (which, given my electrical knowledge, can happen faster than I would like)
The SQLite RTree Module. And another extension for SQLite, this one a standard extension. R-Trees are tree structures optimized for range queries - that is, range queries such as "is this given rectangle contained in the list of rectangles".
The Gaia-SINS federated project home-page. Just quickly bookmarked in case I need it - spatial data (GIS data) can be efficiently indexed and queried in SQLite with an extension. Since I am a declared fan of SQLite, this is quite interesting. And it is implemented as a dynamically loadable extension (of course, this only works if the SQLite you are using is also enabled for extensions - unfortunately this is often not the case, installation might require a recompilation of SQLite, but it's not that terrible).
Sweet Potato Lentil Coconut Milk Soup
Today we were in the mood for soup again. Yesterday I was looking for something and came across this Asian lentil/potato soup, and we decided to try it. It wasn't that difficult and was very delicious. Here's what goes into it (you can also see this in the first picture):
- Sweet potatoes (we had about 750g)
- Regular potatoes (we had 5 small ones, that had to suffice)
- Two carrots
- One mango
- Fresh ginger (we had two small pieces, could have been more)
- Lentils (we had brown lentils, about 200g)
- Vegetable broth (about 1.5 liters)
- One can of coconut milk (400ml)
- Spices (pepper, salt, turmeric, cumin, chili flakes, nutmeg, cloves)
Preparation is also quite simple, it's just a soup:
- Cube both types of potatoes, the sweet potatoes about twice as large as the regular potatoes (sweet potatoes cook faster and otherwise become mushy)
- Chop the carrots
- Chop the onions
- Peel the ginger
- Sauté the onions in oil until translucent
- Add both types of potatoes and sweat them (let them sit for a while until they release moisture)
- Pour the vegetable broth over
- Stir in the coconut milk (don't be surprised, it's partly quite solid)
- Add the carrots
- Add the lentils (if they are very hard and need to cook for a long time - pre-cook the lentils, ours were still quite hard)
- Grate the ginger over the soup (a cheese grater works well for this)
- Add all the spices to taste
- Let the whole thing simmer for about 20-25 minutes
- Remove some of the soup (especially sweet potatoes and regular potatoes) - about 1/2 liter - and puree and mix back in. This makes it nicely creamy.
- Peel the mango, cut it into small pieces, and add it to the soup
- Sprinkle nutmeg over the soup
- Let it simmer for another 5 minutes
- Serve (we had Scottish spiced bread with it)
The whole thing was very filling and very delicious. Quite spicy for our standards because of the chili flakes. But a very interesting flavor combination.
plan 9 was the system that took the ideas of Unix even further and, building on that, enabled a distributed system with distributed resources and seamless networking as early as the late 80s. Just think about where we would be today if it had become mainstream. Tablets that directly use network resources, that directly use complex applications on CPU servers in the network and that the developer can directly access for debugging from his workstation, without any hacks.