The bzr guys just released 1.0 yesterday. Congrats guys! bzr is truly awesome, as in just works, and for the past 1 or 2 years have been been working really good for MMS.
Categories
Categories
Video about ducks
Just finished watching the probably best talk of FOWA again. Watch this brilliant talk, it’s both insightful and funny as hell.
Categories
Server almost Ajaxianized
Ole, friend and collegue from iola, released flot today. Flot is a Javascript plot library for jQuery released under the MIT license. The release got mentioned on Ajaxian and brought the server this blog is also hosted on to its knees. Several hours later, out server is now up and running again with lighthttp as a proxy shield in front of the dear apache server that could handle the load 🙂
Check it out if you need some client side web plotting. The graphs are quite nice since they are antialised and with shadows 🙂
Seeing the new os2008 released for the nokia 800 as well I decided that it was time to upgrade my trusty old n770. The n800 has the same hardware as the n810 but is missing GPS and slide-keyboard. I have a GPS receiver from my n770 navigation kit so I thought I would save the 200 euro and still be one generation behind the latest and greatest internet tablet from nokia 🙂 So far I have been more than impressed with the device. The next OS is absolutely amazing. The layout of the new theme is great (much more finger-friendly), the speed is much improved and the keys are much better than my old n770, making it much easier to navigate around in MMS over VNC.
Another great thing is that it now works with my Samsung E800 phone out of the box so no need to use the terrible hack anymore.
I’m very pleased that I can now finally lift the curtain and show what I’ve been spending most of my time working at iola on.
It’s been a long ride, but now the alpha release is finally ready for public consumption 🙂
Categories
The problem with depending on a server
So here at iola we use subversion internally. It’s ridiculus that the following use case doesn’t work:
<do stuff>
svn commit
<do stuff>
svn commit
<I forgot what I had written in last commit log>
svn log (local copy out of date, only shows revision before the first commit)
svn update
svn: Working copy ‘.’ locked
svn: run ‘svn cleanup’ to remove locks (type ‘svn help cleanup’ for details)
Owned 🙁
Finally got through the mighty Practical Common Lisp tome. The style of the book is written in a nice mix of theory and practice (with relevant and good examples). My friend Lau asked me why on earth I would want to read a book on Lisp? A fair question since Lisp is really old, actually measured in computer time it might even be called ancient. But I had two main motivations for reading the book, to become a better programmer and secondly to better understand new language features introduced in languages like Boo and C#. Just look at the new LINQ features in C# 3.0 and specifically this video.
I wholeheartedly recommend this book to anyone interesting in a good programming book.
Best explaination I have found yet for the Dalvik VM for Android.
Categories
Ohh the irony
Two microsoft licenses approved as open source. It had to happen, open beats closed in the long run.
Categories
C# from a C++ developer perspective
Been wanting to get this out of my system for a while and since I can’t sleep I might as well do something productive.
During my time in iola I’ve begun writing code in C#. I’ve written quite a lot of C++ in the past and still does, so it was quite interesting for me to see what the next iteration of C would be like when I started out with this. This next section is written in a very practical sense, since at the end of the day, that is really what matters.
The nice stuff:
- Fast compiler. I really think this is big. The slow compile time in C++ is contributed by several things, templates are really big here. And since they need to live in header files changing them can easily trigger a cascade effect of recompilation that is extremely detrimental to the whole coding experience. There are hacks around this but they are not really optimal solutions. When I did almost all my coding in C++ I didn’t think of this as a big problem, but once you’ve been seduced by the dark side (Take that Siebel ;-)) you really start to notice it a lot. And the fast compile time of C# makes it much more bare able to write in a statically typed language again.
- Portable library with a lot of useful stuff like threading, network communication, File System abstraction, serialization etc.
- No more dreaded header files. While this may seems strange at first (since header files are a nice way of describing the interface of the classes with comments that don’t get lost in the smoke of implementations), it’s actually really nice not having the headache of keeping
the header files in sync with the implementation, making it much easier to move code around. Another big thing here is the whole template thing. - Delegates (or function pointers if you will) are extremely powerful and having them built into the language makes them very easy to use.
- Support for yield.
- Being able to use the power of .net (Newer in a million years thought utter such words) to mix and match languages. It’s actually quite trivial to write a piece of your program in Boo and have it work with the rest of the code. This is in particularly useful for writing unit tests.
- Perhaps the biggest improvement, although this varies greatly from ones perspective, is that the whole language raises the bar. In the sense that a lot of the BAD programming practice that has been associated with C++, mostly caused by people simply using the language in the wrong way (char pointers, not taking care of memory management, generally pointers comes to mind here) has been stripped away from the language. A really good example of this is to compare the abomination that is pre .net C++ windows code and .net C# code.
- C# is constantly improving and is doing so quite rapidly. Compared to the extremely slow pace of C++ (still hoping for a new standard in this decade!) it’s really refreshing to see a lot of good new ideas being pushed out to people.
The bad stuff:
- Two thumbs up to the designer of C# for stepping up and actually implementing generics in C#. That being said, they are just a shadow of templates in C++ and the whole I-Implement-an-Interface crap is just plain dumb. Templates in C++ compared to generics in C# feels much more like macros in lisp, which if one thinks about it is quite the irony.
- C# is clearly very proud of their garbage collection and thus sees no problem in demanding that everything must be created using the dreaded new syntax. While writing something like: List<string> l = new List<string>(); is not that big of a problem in something like monodevelop or visual studio. But it’s a big pain in the ass if you’re using the one and true editor. Another thing related to the GC is that needed to invent new syntax (using) to support the good programming practice of RAII instead of just doing it by creating objects on the stack and letting them fall out of scope and thus become deconstructed automatically.
- C# falls into the trap of thinking that everything must be an object and that object orientation is the true path to righteousness. Namespaces was invented for a reason you know?
- The built in libraries and especially the documentation is sometimes really really bad. Like methods returning results in different threads than the caller and not writing anything in the documentation about this.
Overall the experience so far has been quite positive and as far as I can see it will only continue to improve. That being said, there are still use cases where C++ is much more optimal and combined with a lot of legacy code C++ will continue to be used for a foreseeable future.