A functional introduction to CEDET – EDE

CEDET is a collection of elisp packages for Emacs designed to turn it into more of an IDE. While it does have the ability to better bridge the gap between editor and IDE, it can be an enormous pain in the ass to figure out; it is “documented” in a rather haphazard way, and resembles an API more than a UI, and as anyone who had to work with uncommented code knows, this is not exactly a recipe for fun.

There’s an article called “A Gentle Introduction To CEDET”, which is pretty good and helped me out in understanding the cacophony of features that is CEDET, but it certainly wasn’t enough. I also spent time reading the manuals for the various sections and had to play with the features before I finally began to comprehend how to get CEDET to do the things I installed it for, and the main take away from this experience was that CEDET has horrible usability, but it’s the best tool we have for enriching Emacs with IDE features, so someone better write an article that addresses CEDET from a functional point of view (i.e. I want to do X) rather than the “understanding the internals” point of view that too often GNU projects take. Today, I’m going to cover EDE, CEDET’s project management module.

Project management

Setting up project management is the very first thing anyone should do to use CEDET, because many of CEDET’s tools use the project definitions to get necessary information. Project management is handled by the EDE component, and supports the following features:

EDE features

  • Manage makefiles: add/remove targets, add/remove files to targets.
  • Project configurations (i.e. debug build, release build)
  • Create distribution file
  • Initiate building, debugging, or running of the project.
  • Viewing and updating project metadata (this includes anything from giving the linker special options to choosing a compiler to updating the project’s version number). This feature is meant for getting down and dirty with EDE, but there’s a GUI for this, so you don’t have to mess around with elisp. Note: this section is described near the end of the post.
  • Searching for files in a project
  • Viewing project tree organized by targets
  • Managing the project’s web site. You can define a “web page file”, a host address, an FTP server address, and a mailing list address for your project. EDE includes the feature to update the project’s website and upload the distribution.

To turn EDE on, place the following code into your .emacs file:

(global-ede-mode t)

When EDE mode is on, and you visit a project, you will see a “Project” option appear in the menubar. Many of the commands I’m about to describe can be accessed via that dropdown menu.

The EDE world view

There is one important thing to understand about EDE, and that is the way in which it looks at your projects.


In EDE’s view, a “project” is files within a folder + their makefile. If you have multiple folders in your codebase, then each one of those folders needs to be defined as a “project” as well, and these “projects” are considered to be subprojects of the top level project.

It’s worth mentioning that EDE is aware of things that happen down the folder hierarchy. You can be at the top folder, initiate a file search, and it will search the entire hierarchy. When you add a subproject, the makefile for the top project is automatically updated to build the subproject as well.

Supported EDE use cases

The question you need to ask yourself when you decide to define a project is which one of the following scenarios fits you:

  1. I’m starting my project from scratch, and want EDE to manage it for me.
    This mode of operations is the most feature complete because as you write your code you set everything up the way EDE wants it to be. This option lets you create either Makefile projects or Automake projects.
  2. I have existing source code that EDE knows how to work with.
    This mode of operation is good for Automake projects, and 2 specially supported projects: Emacs and the Linux kernel. In these situations you need to just go to the source code and EDE will identify everything automatically. This mode of operation is less feature complete, in part because it assumes that since you have existing makefiles, you probably want to keep managing them yourself.
  3. I have existing source code that EDE doesn’t know how to work with.
    In this mode of operations none of the project management features will work, but you can still use EDE to define your code as a project. The reason for doing this is so that some limited amount of metadata will be available for other tools in CEDET. This mode of operation will require you to write elisp code, but you can have a minimal setup with very few lines of elisp. I’ll explain how to do this easily further in the post (there’s a template). Since C/C++ projects with existing Makefiles are common, EDE has a special “project mode” for them.

Note: EDE now supports Android and Arduino projects too. These features appear to be relatively new, and I will not cover them in this tutorial.

With that in mind, let’s go over the 3 use cases…

EDE with new projects

The EDE documentation has a quick start section that is worth looking at for a short example of how to work with EDE for new projects. The general gist is as follows:

Suppose we have a folder hierarchy as depicted in the picture above: a folder with c files and a header, and two subfolders, also with c files and a header in each (currently there are no makefiles or Project.ede files). You need to do the following:

  1. Open a file in the top level folder, and type M-x ede-new. This will ask you for a project name and type: make or automake. This creates a Project.ede file in your directory.
  2. Type M-x ede-new-target or C-c . t, and it will ask you for a name, target type (see below), and if you want to add the current file to that target.
  3. Repeat step 2 as needed to create all the targets you want.
  4. Open a file in the current directory, and type M-x ede-add-file or C-c . a and it will ask you which target you want to add this file to.
  5. Repeat step 4 as needed to add all the files to the necessary targets.
  6. Repeat steps 1-5 for each subfolder, and then their subfolders, and so on.

Supported targets for ede-new-target:

The command ede-new-target requires you to specify what kind of target it is. The following is a list of possible targets and what they are meant for (thanks to Alex Ott from stackoverflow.com for the list).

  • archive – object code archive/static library
  • auxiliary – handles auxiliary files in project – README, *.txt, etc. When I played around with this type of project the header files I added to a “program” target ended up here as well. It looks like this is for files that don’t get compiled.
  • emacs lisp – compiles Emacs Lisp code
  • emacs lisp autoloads – target to create file with Elisp autoloads
  • info – handles texinfo files
  • miscellaneous – target that allows user to compile other parts of project, using user-provided Makefile (one that is not generated by EDE)
  • program – builds executable program
  • scheme – target to handle Scheme (guile) source code
  • semantic grammar – target to correctly build Semantic’s grammar files, both for Wisent & Bovine. This target is defined in Semantic, not in EDE
  • sharedobject – target to build shared libraries

Supported features:

The following is the complete list of features that EDE supports. When working in this manner, they should all work or be supported:

Create target: Creates a target for your makefile, and possibly adds the current file to it.
Invocation: M-x ede-new-target or C-c . t
Remove target: Removes a target from a makefile.
Invocation: M-x ede-delete-target
Add file to target: adds the current file to a target of your choice.
Invocation: M-x ede-add-file or C-c . a
Remove file from target: removes the current file from a target of your choice.
Invocation: M-x ede-remove-file or C-c . d
Building: build the current project or target. You can access more target building options from the menus.
Invocation: C-c . c for current target, C-c . C for entire project.
Debug target: Run a debug session on current target.
Invocation: M-x ede-debug-target or C-c . D
Run target: Run the current target
Invocation: M-x ede-run-target or C-c . R
Create distribution file: Creates a tar.gz file with your code in it.
Invocation: M-x ede-make-dist
Locate files: search for a file in your project.
Invocation: M-x ede-find file or C-c . f
Speedbar: Open a project hierarchy navigation side buffer that shows your files grouped by targets.
Invocation: M-x ede-speedbar or C-c . s
Make distribution: This command will create a tar.gz archive of your project.
Invocation: M-x ede-make-dist
Upload distribution: This command will upload the distribution file to the FTP server you define. Using this feature will require you to define the FTP server’s address via the customization feature, which is covered later.
Invocation: M-x ede-upload-distribution

A personal note:

Having played around with EDE for a bit my impression of it is that it’s cute, but not overly useful. While the initial creation of targets is kinda nice, the moment you decide that you want to do something more you’ll quickly find EDE getting in your way, because it’s nothing more than a layer of (bad) abstraction over the Make system. I’m saying “bad” because an abstraction should mean that you create a new, simpler “language” that the user can use without knowing what is underneath it, but in the case of EDE it doesn’t hide any of Make’s complexities from the user, but rather gives you a different way to specify the things that you want to do, and probably already know how to do by hand anyway (not to mention that unless you know how makefiles work, you’re not going to be able to make any sense out of the customization buffers of your targets).

For example, suppose that you need to compile your code using special flags (-Wall) and link a bunch of libraries (-lm). In EDE this means opening the target’s customization buffer and searching for the option to specify libraries you want to link, and flags you want to pass to the compiler. If you already know what these options mean, you already know how to type them in the Makefile and where, and it would be much more natural to just do that instead of figuring out what’s the “EDE way” of doing the same thing.
What makes this even worse is that the way you specify some options is by overwriting the default values of Makefile variables that EDE generates, and how do you know what these variables are and how they are used? By looking at the Makefile of course! Yes, some of them are pretty standard and once you learn them you don’t need to check the Makefile anymore, but the point is that if you need to reference the internal structure of the Makefile then what kind of an abstraction is this? How is this helping us not mess around with Makefiles (which is presumably the reason we want EDE to manage them for us)??
And if this wasn’t enough, there’s also the myriad of Make features that EDE doesn’t support, which is a headache in its own right if you want to do anything remotely non-trivial. This includes basic stuff like initializing a variable using ?= for example. The EDE workaround for this is to let you define files to “include” into the Makefile, which basically means “write all of that stuff in your own Makefile, and tell EDE to include it in the Makefile that it generates”. Again, if the way to do these things is by hand, it’s going to be much more natural to just write it in the main Makefile, and not write a second Makefile and include it in the first.

In conclusion, this method of working is sort of kinda OK if you want to do some simple stuff, but I can’t imagine any serious project with a degree of non-trivial complexity using it, and quite frankly you’re better off doing the simple stuff by hand as well, because EDE is just going to get in your way, and its extra features like making an archive of your code and uploading it to an FTP server are far from being “killer features” that will make the hassle worth it.

EDE with existing code that EDE doesn’t recognize

For any not-officially-supported scenarios EDE has the notion of a “simple project”, which is basically a do it yourself option. ede-simple-project is an EIEIO object that is designed to be subclassed, and you are free to implement all the necessary elisp functions by hand to support whatever situation you have in your project. If you know how to do that, you don’t really need mu help.

Simple projects are defined by writing elisp code in your .emacs file, and are pretty much featureless. None of the major commands like building and creating targets will work, but the more trivial ones like “Edit Project Homepage” or “Browse Project URL” will, as long as you manually set the appropriate variables in your elisp code (since there’s no Project.ede where settings can be persistent, it is not possible to set this via the customization features of EDE). However, like I said at the start of this post, you will still want to use a simple project even if you don’t plan to extend it, just so that other parts of CEDET will have access to the limited metadata it does have. Otherwise, you may have to configure all the other CEDET tools by hand.

I will however show you how to setup a simple C/C++ project, which doesen’t take much knowledge to do. Its EIEIO object ede-cpp-root-project is special because it’s aware of some typical C/C++ idiosyncrasies like the abundance of .h files. A basic configuration can be created like this:

(ede-cpp-root-project "project_name" :file "/path/to/some/top/level/file"
         :include-path '( "/include" "include/configs" )
         :system-include-path '( "/usr/include/c++/3.2.2/" )
         :spp-table '( ("MOOSE" . "")
                       ("CONST" . "const") ) )

Hopefully most of the stuff you see in this code sample is self explanatory even if you don’t know elisp. Essentially what this code does is give the project a name, tell CEDET where the the project root is by pointing it to a file in that root directory, tells it where the include files are (an entry starting with a “/” is relative to the project root, while an entry that doesn’t start with “/” is interpreted as relative to the current buffer), tells it where the system include files are, and then there’s that spp-table variable.

spp-table is where you can list a bunch of C preprocessor defines that are critical for the various #ifdefs in your code. CEDET can theoretically find them while parsing the code in your project, but placing them here explicitly makes sure that they are indeed found when needed.

You can see a full documentation of ede-cpp-root-project in the EDE manual under the Project/ede-cpp-root-project entry. Examining the inheritance tree can give you the full list of elisp “slots” (variables) you can configure in the above template. The full list is this (items you probably not need to set are grayed out):

  • name: String
    Default Value: “Untitled”
    Used for distribution files. No reason to set this since Make Distribution is not supported in simple projects.
  • version: String
    Default Value: “1.0”
    Used for distribution files. No reason to set this since Make Distribution is not supported in simple projects.
  • directory: String
    Directory this project is associated with. Not sure what its use is considering that this can be inferred with the help of the file variable.
  • file: String
    A name of a file in a top level directory of the project.
  • targets: List
    List of top level targets in this project. This is used by EDE when it generates Makefiles, and I’m not sure of whether you have a reason to set this or not in a “simple project”, although I suspect that it might help other tools find some stuff better if you do (I myself do not bother to set it).
  • tool-cache: List
    List of tool cache configurations in this project.  This allows any tool to create, manage, and persist project-specific settings. If I’m not mistaken this section is for plugging in custom tools (notice that the “tools” section of customize-project is always empt).
  • web-site-url: String
    URL to this projects web site.  This is a URL to be sent to a web site for documentation.
  • web-site-directory: String
    A directory where web pages can be found by Emacs.  For remote locations use a path compatible with ange-ftp or EFS. You can also use TRAMP for use with rcp & scp.
  • web-site-file: String
    A file which contains the home page for this project.  This file can be relative to slot `web-site-directory’.  Same guidelines as above.
  • ftp-site: String
    FTP site where this project’s distribution can be found. This FTP site should be in Emacs form, as needed by `ange-ftp’, but can also be of a form used by TRAMP for use with scp, or rcp.
  • ftp-upload-site: String
    FTP Site to upload new distributions to.  Same guidelines as above. If this slot is `nil’, then use `ftp-site’ instead.
  • configurations: List
    Default Value: (“debug” “release”)
    List of available configuration types.  Individual target/project types can form associations between a configuration, and target specific elements such as build variables. Not useful to you unless you plan to write your own elisp functions that use this.
  • configuration-default: String
    Default Value: “debug”
    The default configuration. Not useful to you unless you plan to write your own elisp functions that use this.
  • local-variables
    Default Value: `nil’
    This variable is for setting Emacs variables that you want be set only for this specific project.
  • include-path: List
    Default Value: `(quote (“/include” “../include/”))’
    The default locate function expands filenames within a project.  If a header file (.h, .hh, etc) name is expanded, and the `:locate-fcn’ slot is `nil’, then the include path is checked first, and other directories are ignored.  For very large projects, this optimization can save a lot of time.
    Directory names in the path can be relative to the current buffer’s `default-directory’ (not starting with a /). Directories that are relative to the project’s root should start with a /, such as  “/include”, meaning the directory `include’ off the project root directory.
  • system-include-path: List
    Default Value: `nil’
    The system include path for files in this project.  C files initialized in an ede-cpp-root-project have their semantic system include path set to this value.  If this is `nil’, then the semantic path is not modified.
  • spp-table: List
    Default Value: `nil’
    C Preprocessor macros for your files.  Preprocessor symbols will be used while parsing your files.  These macros might be passed in through the command line compiler, or are critical symbols derived from header files.  Providing header files macro values through this slot improves accuracy and performance.  Use `:spp-files’ to use these files directly. I myself do not bother setting this.
  • spp-files: List
    Default Value: `nil’
    C header file with Preprocessor macros for your files.  The PreProcessor symbols appearing in these files will be used while parsing files in this project.  See `semantic-lex-c-preprocessor-symbol-map’ for more on how this works.
  • header-match-regexp: String
    Default Value: “\\.\\(h\\(h\\|xx\\|pp\\|\\+\\+\\)?\\|H\\)$\\|\\<\\w+$”
    Regexp used to identify C/C++ header files. If you need to set this then wat.
  • locate-fcn: function (or null)
    The locate function can be used in place of “ede-expand-filename” so you can quickly customize your custom target to use specialized local routines instead of the EDE routines.  The function symbol must take two arguments:   NAME – The name of the file to find. DIR – The directory root for this cpp-root project.
    It should return the fully qualified file name passed in from NAME.  If that file does not exist, it should return nil.

EDE with existing code that EDE recognizes

As mentioned before, there are a few use cases for this option: Automake projects, Linux project, and the Emacs project. It is worth noting that in EDE’s eyes, existing Automake project and Linux/Emacs projects are actually two different things. Linux/Emacs projects are essentially “simple projects” that are preconfigured and prepopulated with symbols.
I don’t have much to say about this option. It’s going to be somewhere between “simple project” and a fully featured project type.

Advanced: Low level customization of your project

Most of EDE’s project metadata isn’t accessible from the high level commands described above, so in order to customize it you either have to edit the project definition by hand, or preferably use the customization feature. This feature worksin two possible situations:

  1. Your EDE setup uses a Project.ede file (use case number 1).
    If your setup uses a Project.ede file, the customization feature will take you to a special buffer similar to Emacs’ “customize” buffer.
  2. Your EDE setup does not use a Project.ede file (use cases 2 and 3).
    In this situation EDE is either using Makefiles or some other file to learn about the project’s setup, and the customization feature will take you to these files themselves. For example, if you are in the Linux project, and type C-c . e, it will take you to scripts/ver_linux.

The customization buffers can be accessed via the Project menu, and look something like this:


As you can see, the different options are documented. Some of the documentation in there is helpful, other not so much. Since this post is already long enough, I’ll focus on describing what I personally feel is the non-obvious stuff.

  • Default:
    • For Automatic-Dependencies, Include-File, and Inference-Rules you can view this post.
  • Settings:
    • Variables: literally insert variables into the makefile.
    • Configuration-Variables: insert variables that will only be used when compiling with the appropriate project “configuration”.
    • Project Local Variables: set Emacs settings that will be relevant only for this project.
  • Targets:
    • Auxiliary Files under “Local Targets”: when I added header files to my project, they ended up here, which is not what I would’ve expected given the description in the documentation.
    • Linker and Compile options: I didn’t set any, and it appears that this causes EDE to default to GNU tools like GCC.
    • Additional Rules is for inserting hand written rules.
    • LdLibs: despite what the documentation says, this is perfectly supported in Make projects as well.

Confused yet? I don’t blame you.


If you want my opinion: don’t bother working with EDE directly. It’s not really worth it. Just write your own Makefiles, and use EDE’s ede-simple-project or ede-cpp-root-project to define where your includes are, and if you want to- what you web site URL and FTP address is for all those cutesy features. If you don’t want to pollute your .emacs file with project specific definitions, you can do the following:

Place this code into you .emacs file:

;; Create a Project.ede equivalent for ede-simple-project
;; by telling Emacs to load Project.el files
(defun check-for-Project-el ()
  (if (file-exists-p "Project.el")
    (load-file "Project.el")
(add-hook 'find-file-hook 'check-for-Project-el)

This function makes Emacs check for the existance of a Project.el file whenever it opens some file, and loads its elisp code. Now, place a Project.el in your project folder, and write all the configuration there.

So that’s it for now. Next time I’m going to cover Semantic.

Posted in Open Source, Software | Tagged , , | 3 Comments

iTunes annoyances

I’m eagerly waiting for Windows Phone 7 to finally come to Israel. The primary reason is that I’m very excited about the interesting stuff they did with it and really want to try it, but there’s another, secondary reason that isn’t as important but will make me so much happier: I want to get rid of iTunes already.

iTunes may have started as a simple and elegant player, but by now it’s pretty broken, in many ways and in all the most annoying places, and what’s really aggravating about it is that Apple just doesn’t seem to care. So many of the problems I’m going to rant about are easily fixable, and in many cases shouldn’t have been problems to begin with, and every time another update arrives I think to myself “well, maybe this time they’ll finally fix everything”, but no. The result is a program that could’ve been great, but instead is the most complained about program in Apple’s iSoftware collective, and quite frankly is the most un-Apple-ish program of a company that prides itself on simplicity and attention to detail.

In no particular order, this is why I hate iTunes:

It’s slow

iTunes is ridiculously slow for a media player. Long start up is one problem, but it’s the bad responsiveness that really gets to me. Every time I plug my iPhone into the computer I know I’m going to have to wait a few seconds before iTunes registers anything that I’m doing, even if I just want to open my music collection. It gets better once it’s done backing up the phone, but still feels somewhat sluggish and there are still unexplained hangups.

As a software engineering student I can understand that getting tech right can be tricky, and I can be very forgiving when I see that the deficiencies are the result of the difficulty of the problem. But in this case it’s not a matter of the difficulty of the problem, it’s a matter of Apple being incompetent. How do I know that? Because the Zune software is much more graphically intensive and yet outperforms iTunes all the time on my computer, and if Apple still can’t do updates the smart way (their idea of a software update is an automated redownload and reinstallation of the whole program) then it doesn’t surprise me they can’t figure out what efficiency means. I guess developing only for high end laptops can spoil you.

The way it handles metadata is terrible

iTunes has so many metadata fuck ups that this is the thing that gets on my nerves the most. Take the following picture for example (you can enlarge it):


You will notice that the tracks for Belus and Burzum are misarranged. Why is that? It knows they belong to the same albums, they are all numbered, and yet it doesn’t sort them correctly. Want to guess why? In Burzum it’s because track 6 doesn’t have “Disc number 1 out of 1” filled in. What kind of weird ass sorting algorithm could they possibly be using there that takes a collection of numbered tracks that it knows belong to the same “entity” (Album name) and fails to sort them in the correct order unless you explicitly tell it that there’s only 1 CD (like it matters)?!
(Don’t answer this. I know why it does it and it’s stupid).

You know where this gets really annoying? When you sync these tracks to your iPhone and suddenly realize they are playing in the wrong order. And of course I can’t fix this via my iPhone because that would require another UI element that will confuse my poor technically challenged grandma, so I have to live without it too, changing the songs manually as I go instead of letting the player do this for me. (yes I can also create a playlist. Do you think I want to have to do that?)

Its lack of support for multiple artists/composers is also a source of great annoyance to me. All of Microsoft’s media players know that “Composers: John 5; Twiggy Ramirez” means that there’s a distinct composer called John 5, and a distinct composer called Twiggy Ramirez, and that they collaborated together. So if I ever wanted to get a list of all songs where John 5 was a composer (for example- for making a John 5 playlist), all I need to do is go to the single John 5 entry and all those songs, with or without collaborators, will be there.


iTunes is not that smart apparently. If you give it “John 5; Twiggy Ramirez” as composers it’ll go ahead and create a new artist called “John 5/Twiggy Ramirez” on top of the existing John 5 and Twiggy Ramirez artists, and will associate the track to that new “artist”. The result? FRAGMENTATION (enlarge to see the problem at its full glory).


…and if you think the single “John 5” entry on iTunes consolidates all the tracks- it doesn’t. It only shows tracks where John 5 was the sole composer. So now to make a John 5 playlist I need to go to each one of those entries, in a constant back and forth between the search results, and and hunt down the tracks I need, all for no good reason.

The iPhone also inherits this problem. Since you can’t sort your iPhone’s music by “album artist”, only by “artist”, then for example if you have a duet between the artist Burzum and Euronymous on Burzum’s self titled album (so this track’s artist will be Burzum/Euronymous), that track will not be in album Burzum when sorting by the artist Burzum, and instead will end up in an entry for the the new “artist” Burzum/Euronymous.

So if you want to listen to the album from start to finish you have to either access it via artist Burzum and manually switch to that track when the time comes, or you will have to hunt down the album when sorting your collection by albums, which is less convenient than sorting by artists. Thanks Apple.

Oh and speaking of sorting by artist, how do you like this little gem?:


Thank God I have my iPhone to notify me of trailing whitespace in my metadata. After all, we don’t want the two different bands “Dark Funeral” and “Dark Funeral ” to be mixed up. They play totally different genres. One is Black Metal and the other plays children’s songs.

Too lazy to fix this for me, iTunes?

The brain-dead way it handles unknown tracks

Suppose you have a folder with files, and you decide to import it to iTunes. God help you if one of those albums lacks metadata. You will end up with an “Unknown Artist” entry for every damn track.

itunes 6

WHY?! Who the hell thought this was a good idea?! Media Player at least aggregates all these unknown tracks to the same “unknown artist” entry, and then you can use the “File path” column to quickly make sense of the mess. In iTunes I have to enter each “Unknown Artist” entry and change the data track-by-track. And you’d think iTunes could at least be smart enough to know that if you rip a CD and it doesn’t recognize the artist, all songs are probably from the same artist (simple statistics of number of LPs vs various artists collections). But no, you still get one entry of “Unknown Artist” per song. Really, Apple? You call that user friendly?

Its weird and unnatural selection mechanism

Remember the time when holding down shift, pressing down to select some tracks, and then pressing up did not deselect the last selected track but instead selected additional tracks above the current selection?

So they fixed it in song selection, but apparently it hadn’t occurred to them to do the same in the artist view. So suppose you just imported a folder with no metadata in the files and got 500 “Unknown Artist” entries in your library, and decided to delete them, use mp3tag and then reimport them. You better be really careful if you plan to select these folders using the keyboard, because this non-standard selection scheme makes it impossible to fix your selection if you selected too much. In fact, it’s way worse than that. The selection scheme makes no (good) sense. Go ahead and experiment with it. It sort of feels like playing Snake, except that you quickly realize that it only acts like that some of the time, and that the left key is really bound to the “up” side of the snake, and the right key to the “down” side. It’s overall confusing.

Snake: the iTunes version. FYI, original selection started at Venom. Yes, this is done with a keyboard.

While most file/music/whatever managers remember your position in the collection of items after you do deletion (so when you press to the right for example it would select the item to the right of the selection you just deleted), iTunes doesn’t remember anything, and pressing right will make you jump to the top of the artist tiles, forcing you to rescroll down to select what you wanted to select.

It doesn’t watch the file system for changes

Every media library organizer that respects itself can do this, why can’t iTunes do this too?! This was the feature that made me figuratively fall in love with the latest Media Player. You drop some files into your music folder, and it automatically finds them and adds them to the library. You change some metadata in one of those files- Media Player updates itself automagically. It’s one of those features that once you have them you don’t ever want a media library organizer without it. …and iTunes doesn’t have it.

This to me says that Apple doesn’t care that some people don’t get all their music from iTunes. If you buy music from the iTunes store it’ll update its library for you automatically, but if you’re not an iTunes customer- screw you, you’re on your own. So now for every new album that I get I have to manually import it to iTunes, and if I move something, I have to update iTunes manually again. If you change some metadata outside of iTunes, it at least will recognize this when you use it to access said file, but it doesn’t have a very good track record where album covers are involved. Usually, album covers inserted in Media Player (fully committed to the hard drive) fail to be detected by iTunes, and I have to reinsert the album cover via iTunes itself. Again.

All of this is stupid and unnecessary hassle. In that respect iTunes is behind even some of the crappiest Gnome media players that litter the Ubuntu software center, and there is some serious crap in there.

UI lameness

Why the hell is burning a CD achieved via a playlist? How is that natural? Not every CD that I want to burn is a song collection that I want to listen to in the future. Why do I have to go through the hassle of creating, and then deleting, a playlist? And you know what else sucks? I can’t create a playlist without it taking me to the screen that explains what a playlist is, so now I have been thrown out of what I was looking at and have to go back.

What about all those checkboxes next to every song? What are they supposed to be about? Am I supposed to guess? Will I win a white iPhone if I do? (And don’t write to tell me what they are- I know what they are. But they have no explanation in the UI. You have to dig in the help file or experiment to figure out their function).

By the way, the iTunes UI really hasn’t aged well. Have you seen the Zune software? It’s beautiful. Blows out of the water everything Apple ever did. iTunes looks like something from the 90’s. Still. And in all the years of accumulating features it has been extended in the most naïve, ungraceful way. Got a new feature? Throw in another section to the side bar! I agree that there’s an ease of access element here, and that this scheme is not bad per se, but there’s an invisible line where it stops looking good, and iTunes has crossed it. It just doesn’t feel elegant anymore (and don’t get me started on the iTunes store).

Crippled if the iTunes store is not available

So I get it, the anal record industry wants you to get a license for every note of every song you make available in the iTunes store. But why can’t I access the related data? In Media Player I can right click an album and ask it to fetch the album information from the web. I get metadata, covers- the works. iTunes doesn’t offer that to me. Sure, it has the option to fetch album artwork, but I can count on 0 hands the amount of times it found anything for my library. I think it just doesn’t work because I’m not in an iTunes store enabled country, and that’s dumb.

What about Ping? Why can’t I use Ping to network and follow artists? Because “the experience will be crippled seeing as I don’t have access to the tightly integrated iTunes store”? My experience is already crippled.
In contrast to this, Microsoft’s Zune social network is available to everybody.

But maybe I should leave this alone, since I’m not sure why I would like to get in to begin with.

I think this about sums up what I hate about iTunes.

Do you hate iTunes too? Feel free to tell me about it.

Posted in Apple, Software | 7 Comments

5 Interesting hobbies that don’t include sitting in front of a computer

Computers have taken up the role of the enablers of so many things that it seems like there’s absolutely nothing to do once your computer is out. Let’s do a quick checklist to illustrate that:

Things I do with my computer

  • Watch TV
  • Watch movies
  • Play games
  • Talk to friends
  • Read books
  • Listen to books
  • Write
  • Create graphics
  • Edit video
  • Practice playing guitar (aided by the computer)
  • Study
  • Mail
  • Check news
  • Check calendar

    Check the time (and I have a clock right above my screen)

    …and frankly this list doesn’t do justice to the the biggest, most important service it gives me: it’s intellectually stimulating.

    Whether it’s playing chess or programming, learning about stuff on Wikipedia or participating in online debates, computers and the internet are both the second most important brain trainer in my life after the university I’m attending. Without it, I would be terminally bored.


    But before there were computers, somehow people managed to find things to do, or maybe what I should be saying is that- even intellectuals managed to find things to do. Darwin had his pigeons, Feynman repaired radios and had cryptology contests with his wife, Einstein was… figuring out how to have sex with his cousin… Everybody managed to find some way to stimulate their minds, and we can still do that now, even without computers.

    The following is a list of “hobbies for smart people” that you can engage in without sitting in front of computers. A few of these will be obvious suggestions, but many will not. By “hobbies for smart people” I’m talking about things that satisfy the following criteria:

    1. There is a lot to learn about them.
    2. They are challenging. Not necessarily in an intellectual way, but preferably so.
    3. The more you immerse yourself in them, the greater is the pay off. Presumably you can spend years doing them and still feel like you have something to learn/improve.


    OK so this is one of those obvious entries I mentioned, and I wanted to start with it first because it is a game that has so much depth that it can really be the only thing you need to get yourself occupied for hours. Chess is a game of skill and of intellectual prowess, and it can take time before you get good at it, but the nice thing about it is that the better you get- the more rewarding it becomes.

    Beginner players are often only able to look at the individual pieces; they find it difficult to plan ahead and generally play as if the game is a skirmish between the different pieces, and your goal is to somehow manipulate it so that it ends in your favor. If they can exchange pieces they immediately do, if they can capture a piece they will do so, and then somehow their opponent out maneuvers them in a way they couldn’t possibly foresee, and mates their king. But as you progress you start to notice patterns, and you start to notice the pieces in the context of their environment. You begin to consider positions, and tempo, and treat empty squares as important resources you don’t want your opponent to have. You begin to plan further ahead, analyze your opponent’s strengths and weaknesses, and even sacrifice major pieces for strategic advantage. Your strategy becomes more sophisticated, and the possibilities for creativity soar high.

    The following commentary on a Karpov vs. Kasparov 1985 World Championship game from thechesswebsite.com should give you a great example of what I’m talking about:

    Here’s another game, this time not Grand Master level, but still interesting:

    If you like this, go to thechesswebsite.com where you will find not only commentaries, but also lots of chess puzzles and strategy tips. Follow them on Facebook too.

    Amateur Astronomy

    When we think about Astronomy we think about huge, multi million dollars telescopes, space probes, and an astro physics degree. But the truth is that there are actually lots of amateur astronomers who can spot nebulas, stars, and satellites all with a reasonable budget. Yes you heard it right.

    This is not the cheapest hobby in the world, but it certainly has a cheaper entry fee than a computer (unless you’re one of those people who buy netbooks, in which case my advice is to get a real computer and stop screwing around with toys). You can buy a great beginners telescope for $300, according to this web site, and this should be enough to get you to notice some interesting things.

    Astronomy is a very scientific and technological hobby- there’s quite a lot to learn about it: technical details about telescopes, high tech imaging methods for telescope photography, information about the different galaxies and star charts, and even the physics of optics, and the more you learn about it the greater your reward will be: better viewings, better photography, and better sense of our place in the world. For most of us space is something that we could never explore for ourselves, and there’s something very epic in the realization that, actually, yes we can.

    So what can you see as an amateur astronomer? Believe it or not, some damn amazing things. For example, the images in the following video, are actual images taken with a telescope, and that includes the ones that look too good to be true.


    I looked around YouTube and found a lot of similar videos taken by amateur astronomers that also included the models of their equipment in the info section, and most of it was definitely not super expensive.

    From the author of this left one: “Yes, it is a very decent scope. Not on the pro end, but definitely a good beginning and intermediate scope. The 10″ is good too..if you want a bit more aperture and weight. “




    You should not expect to see such great images on your first try, especially since they also depend on how still the air is, but yes, these are possible.

    You can also use your telescope to take some amazing pictures, like this guy did.

    Here’s one of his images, and I suggest that you follow the link for the rest. image

    He uses a professional telescope, but let’s face it, if you can afford a Macbook Air, you should be able to find a way to afford his telescope as well.
    The more advanced you’ll become the more you will have a need to take a laptop with you, but the point is that you’ll be going out, camping in the outdoors, and looking at the stars for real.

    Here are a few links to get you started:

    Buying a Telescope… Advice for Beginners
    General basics

    Vehicle Engineering

    There are plenty of people who build small scale, motorized models of planes, boats, submarines, helicopters, and even small rockets with various types of launch systems, all of which can fly/float/swim for real. Building a remote controlled plane that can actually fly from scratch would require a lot of planning, good craftsmanship, and of course- time to learn the aerodynamic principles and electronics side of things. Building a boat that’ll float should be easier, but will still require planning and craftsmanship on your side. But the point is- if you want an intellectual challenge, you got one. And while complicated, it is also a feasible thing to do.

    But you don’t even have to do the whole thing from scratch. There are plenty off the shelf models for self assembly, and even when you have that part of the work done for you, it doesn’t mean you can’t add your own improvements…

    You can mount a camera on it and film your flight
    You can strap a smaller airplane to it and launch it in flight








    Frankly just flying it should be a lot of fun, but as I’m writing this I find it difficult to suppress the image of mounting a rocket-launcher/BB-gun on two off the shelves model planes and have a fight to the death with someone. (death of the plane, not the controller).

    These guys know what I’m talking about!
    If flight is not your thing, you can try building a hovercraft or a submarine. These too can be equipped with miniature weapons by the way.








    Rockets are an entirely different deal, and you will have to come up with a way to get them off the ground, keep them stabilized, and get them to fly as high as possible. This might involve some deal of chemistry, and figuring out an ignition system. Gyroscopes might be involved.

    Of course if you are John Carmack, you may want to skip the bullshit altogether and start building space rockets. Just don’t expect to do that for 20 bucks.

    Playing music

    This might sound like a peculiar suggestion for an “intellectual” hobby, but it’s more relevant than you think. Playing musical instruments actually uses a lot of different areas of your brain simultaneously. In fact, some people theorize that this is why women are often attracted to musicians- the skill tells them that that person has a well developed brain. So it is, in fact, a pretty good mental workout, and it actually goes both ways; many musicians say that performing a brain intensive task like reading a complicated book or doing math actually improves their playing ability. I myself felt short term gains in accuracy after doing math, and feel long term gains in accuracy now that I have 3 years of computer science education behind me, so as a training mechanism for your brain it’s not a bad one because it’s all intimately connected.

    Music is also a vast domain and you can study it for years without ever reaching the limit of what can be known about it. There’s a huge wealth of ideas to familiarize yourself with, many different levels to excel on (technique, creativity, style, feel, etc.), and there is a well defined underlying theory to it that acts as the back bone of the field.

    To get you started with inspiration, here are a few songs by a band which I feel excels in all aspects of music making- technique, creativity, style, sound, feel, and just about anything else you can think of- the mighty Dream Theater.

    Under A Glass Moon from Images and Words
    Forsaken from Constant Motion
    Hollow Years, originally from Falling Into Infinity
    Overture 1928 + Strange DejaVu, originally from Scenes From A Memory

    …or you can just browse my favorite artists in my profile page.

    Role Playing Games

    If you need convincing that investing yourself in (A)D&D is a non-trivial intellectual endeavor, I’d like you to consider the following picture:


    According to the author what you see here is:

    From top to bottom:
    * D&D 3.5e
    * D&D 4E
    * Battletech
    * AD&D Rulebooks
    * AD&D 2nd Edition Rulebooks and supplements
    * D&D 3rd edition
    * A very small number of d20 System publications
    * AD&D 1st & 2nd edition Modules and Boxed Sets (mostly 1st edition).


    Aside from the huge collection of rules, monsters/items/spells statistics, and fantasy world concepts that there are to learn, role playing games can also be as intellectually loose or strict as you want to. There’s certainly enough formalism and potential in most systems for them to be very strategic games, and the level of difficulty and challenge is all a function of your Dungeon Masters’ creativity and imagination. These are games that give you the tools to challenge yourself as you see fit, and the nice thing is that you also have the option to be either a player who tries to play through the adventure, or the Dungeon Master- the person who comes up with adventures for the group and acts as the driving engine behind them. In that role, you’re essentially building puzzles, worlds and conspiracies, and take on many roles as the group comes across the inhabitants of your world.

    But these games also have a nice perk in that they are social activities, and when you have a good group going it can be very fulfilling in that respect as well. In fact, from all the videos I’ve seen of D&D sessions I’d say that role playing games really tend to be more of a social activity than an intellectual one, but then again it really all depends on your group. Finally, if none of this is enough for you, you can try to invent your own system, which would mean an added mathematical challenge as you try to balance the different attributes of the game elements. I can guarantee that seeing the finished result being experienced by other players will be very satisfying.

    The following links should help you started on role playing games.

  • Posted in Geek culture | 7 Comments