Yes, it’s possible. Even if Objective-C is one of my preferred programming languages, in any case I think it’s worth mentioning that, 2 years after the official iPhone SDK has been announced, the iPhone development landscape has really grown up, and many, many different options are available today. This article provides a very high-level enumeration of some options I’ve found on the web, but I’m sure there are even more alternatives around.
Here it goes: Continue reading
You might remember my beloved mantras: learning a new programming language and reading at least 6 relevant books every year. Following the 2007 edition, here’s the list of the 8 books I have enjoyed most in 2008, ordered by a purely subjective and absolutely irrational decreasing preference. I strongly recommend all of them!
Winner: Geekonomics: The Real Cost of Insecure Software by David Rice
Runner-up: The No Asshole Rule: Building a Civilized Workplace and Surviving One That Isn’t by Robert I. Sutton, PhD
And 6 more:
I’ve sent the final version of my dissertation to the University of Liverpool. I’ve been doing this Master’s degree since 2005, and now it’s over. It feels good and weird at the same time.
Rem 1.0, the final result and main objective of my Master’s thesis work, has been released today. A small, simple, yet extensible and portable UML tool written in C++, using Juce, POCO and SQLite. Not perfect but extensible and small. And that’s what’s great about it.
Xcode is amazing. Of all the IDEs I’ve used (and this is, as always, a personal opinion, having used Visual Studio since version 6, Eclipse, Kdevelop and others) it’s the one I prefer. And today I found another reason to like it.
I’ve noticed this: when I use Xcode on a single-processor machine (such as a Powerbook G4) and I rebuild my master thesis project (in C++) I see this build window:
No big deal: each file is compiled, one after the other. However, it seems that when I run it on a dual-processor machine (both in my dual G5 desktop and my Intel Core Duo 2 MacBook) I get a boost in compiling time, with parallel compilations! See this:
Then, coupled with Bonjour networks, you can even go faster, using the processing time of your peers’ computers to have smaller compilation times.
ImageMagick is a cool toolkit; not only it’s a complete set of command-line applications, ported to Windows, Mac and Linux, supporting hundreds of different image formats, it’s also a C++ library that you can use in your own applications!
On Mac OS X, I installed it via MacPorts using the all-time classic:
sudo port install ImageMagickThen I created a C++ command-line application with Xcode, set the header and library paths in the target properties (/opt/local/include/ImageMagick and /opt/local/lib in this case) and I was ready to code. The API documentation and the tutorial give some hints, and using those examples I’ve cooked a quick image transformation utility to play with:
[source:c]
using Magick::Image; using Magick::Geometry; using Magick::Blob;
int main (int argc, char * const argv[]) { Blob blob;
Image png;
png.read("pic.png");
png.write(&blob);
Image jpg(blob);
jpg.magick("jpg");
jpg.zoom(Geometry(100, 200));
jpg.write("newpic.jpg");
Image tiff(blob);
tiff.magick("tiff");
tiff.zoom(Geometry(3000, 84000));
tiff.write("newpic.tiff");
Image gif(blob);
png.magick("pdf");
png.write("newpic.pdf");
return 0;
} [/source]
Interesting stuff indeed! The API provides a complete set of “Photoshop-like” operations on images, which I plan to study further in the near future.
Did you knew this is possible in C++? I didn’t.
[source:c] void Fun() { class Local { //… member variables … //… member functions … };
// ... code using Local ...
} [/source]
This feature is called “local classes” and is part of the standard; the limitations are that these local classes cannot have static member variables and cannot access nonstatic local variables. But, as Alexandrescu points out (page 28), you can use them in template functions:
[source:c] class Interface { public: virtual void Fun() = 0; // … };
template
virtual void Fun()
{
obj_.Call(arg_);
}
private:
T obj_;
P arg_;
};
return new Local(obj, arg);
} [/source]
Not only that, but partial template specialization and template-based compile-time verifications just blew me away. The second chapter of the book was realizing I just haven’t had the slightest clue about all the cool things you could do with C++!
Take a careful look at this:
[source:c]
class Gadget { public: void sayHello() const { std::cout << “Gadget!” << std::endl; } };
class Widget { public: void sayHello() const { std::cout << “Widget!” << std::endl; } };
template
template
template class T, class B> class Creator : public T { public: void exec() { B* obj = this->create(); obj->sayHello(); delete obj; } };
typedef Creator
int main (int argc, char * const argv[]) { Manager obj; obj.exec(); return 0; } [/source]
Try changing “MallocCreator” by “OpNewCreator” and “Widget” by “Gadget” in the typedef of line 57, recompile and run; of course you can provide default values, so that
[source:c:firstline(44)] … template class T = MallocCreator, class B = Widget> class Creator : public T … [/source]
so that you just do
[source:c:firstline(56)] … typedef Creator<> Manager; … [/source]
I’ve just started reading “Modern C++ Design” by Andrei Alexandrescu and I’ve already my head spinning out of orbit. This is amazing (and by giving a quick look at the rest of the book, there’s even more incredible stuff there)!
JUCE is a gorgeous thing:
JUCE (Jules’ Utility Class Extensions) is an all-encompassing C++ class library for developing cross-platform applications. It’s particularly good for creating highly-specialised user interfaces and for handling graphics and sound.
For Mac OS X (with the Developer Tools installed) and Windows (using Visual Studio 6, 2003 or 2005), the library builds out-of the box (well, almost: on Windows you need to have QuickTime and the ASIO SDK installed). However, for Linux there are a couple of external dependencies.
This is a small tutorial (and a reminder for myself, as usual) for those interested in building JUCE on Kubuntu 7.10 “Gutsy Gibbon” (these instructions should also be useful for other Linux distributions, but I cannot tell for sure). Continue reading
This is a rant: I am tired of seeing virtual methods implemented in child classes that, at some point or another, call the method of the same name in the base class. For me this is a sign of poor architecture. A bad, bad smell in code.
Let’s say that you have a base class, called, well, BaseClass (the examples are in C++, but you can take this idea to any other OO language):
[source:c]
class BaseClass { public: // constructor, destructor, copy // constructor, assignment operator…
virtual void doSomething();
}
void BaseClass::doSomething() { // provide some basic behavior here, // and a comment that says something like:
// IMPORTANT NOTE to implementors of subclasses:
// this method should always be called before your code!
}
[/source]
And then you derive a class from this base class, called, well, DerivedClass:
[source:c]
class DerivedClass : public BaseClass { public: // constructor, destructor, copy // constructor, assignment operator…
virtual void doSomething();
}
void DerivedClass::doSomething() { BaseClass::doSomething(); // WTF???
// do something else...
}
[/source]
As stupid as it might sound, this code is hard to understand, debug and maintain, because it includes an unneeded dependency from the child to the base class – that is, another one, besides the fact that one derives from the other!