Yoshiki's personal blog

Yoshiki's personal blog and outlet for thoughts, ideas and things worth talking about. For a description of the author see the about section.

[yoshikee]

Introducing Keystats

Stephen Wolfram’s “The Personal Analytics of My Life”, made me wonder about things like: How many keystrokes do you type a day? What keys do I use the least/most? Which application do I use the letter ‘z’ the most? Then last year I got my first mechanical keyboard so I figured I had to do something about it.

When I tried to start collecting the data to answer these questions, I realized that I would need a keylogger, sadly there was no keylogger that was both free, open source and provided an easy way to query your keystrokes. After playing around with some of Apple’s APIs, I came up with a very simple and barely usable prototype, today after a year and about 30 days of sporadic development (git log says so), I release Keystats 1.0.0.

Keystats stores all your keystroke data into a SQLite database, so you can query for anything you need, for example:

The top five most used applications in the past 7 days:

sqlite> SELECT bundle_id, count(bundle_id) FROM keystrokes WHERE timestamp >= strftime('%Y-%m-%d 00:00:00', 'now', '-7 day', 'localtime') GROUP BY bundle_id ORDER BY COUNT(bundle_id) DESC LIMIT 5;

com.apple.Terminal|118276

org.vim.MacVim|42550

com.apple.Safari|39149

com.apple.iChat|37178

com.wolfram.Mathematica|4182

Now let’s look at an application in specific (for example MacVim) and the count of the three most used keys:

SELECT ascii, COUNT(ascii) FROM keystrokes WHERE bundle_id = 'org.vim.MacVim' GROUP BY ascii ORDER BY COUNT(ascii) DESC LIMIT 3;

j|42776

l|35556

k|35078

These are just two trivial examples that you could have otherwise inferred because: (a) I write software on a daily basis using vim and (b) I make inefficient use of the navigation keys, however this goes to show the kind of things you can do.

The intent is not to make Keystats the ultimate resource to analyze your keystroke data, but instead to provide a flexible source (read database) to answer the questions you have.

For every keystroke you type, the following information is obtained and logged into the keystrokes database:

Current time with the following format 2013-12-27 00:17:40.

Key type.

Key code.

ASCII representation.

Front-most application's bundle identifier (Safari -> com.apple.Safari).

Keystats is hosted on Github.

Keystats is not intended and should not be used as a malicious application, it is the responsibility of the end user to make legal and safe usage of the program.

[yoshikee]

Mutt, patches and GitHub

Earlier this week, I saw this thread on r/vim, a few of these apps looked interesting but nothing too amazing, until I saw mutt, it immediately caught my attention, the gist of it: "an e-mail client with vim-like bindings". I thought to myself: "this can either be fantastic or horrible", I tried to install it in OSX and had no luck.

Later that day, I sent that link to my friend Santiago, who also thought mutt was an interesting idea, so he installed it (in his linux box) and immediately sent me an e-mail from mutt. I was both intrigued and jealous, so I decided to give it another try, sure enough brew (the missing package manager for OS X) provides a formula to install mutt. However when I ran the executable I noticed that I didn't have a few capabilities that Santiago described having, after more investigation i. e. running mutt -v, I noticed that there are a bunch of compilation flags to be passed to mutt's configure file, all of which enable/disable: imap, smtp, header-caching, etc.

In no time I was downloading the source and compiling from scratch, it took me a while but the ./configure command ended up looking like this:

CPPFLAGS=-I/opt/local/include/ LDFLAGS=-L/opt/local/lib/ ./configure --with-ssl --enable-pop --enable-imap --enable-smtp --with-sasl --enable-hcache --prefix=/usr/

Note that setting the CPPFLAGS variable is only needed because I used macports to install some of mutt's dependencies.

Anyways, I was up and running, but it looked too plain and not very usable (see screenshot below) which made me rethink why was I doing this.

Note that I was doing all this around 11:00 pm and I still had a lot of things to do before waking up the next day, I decided to hand over this win to mutt and continued working.

The next day I was using Mail.app and of course I was getting tired of it, it seriously has decremented its usability lately (at least for 6 accounts with a total of 40K e-mails). Hence I decided to load mutt and answer a couple e-mails with it. Later that day I found that Steve Losh had blogged about mutt with this more than appropriate title "The Homely Mutt". That blog post was super useful and I ended up going from a crappy looking and barely usable mutt to something like this:

Note that the colors are a custom modification of Solarized plus some additions. Like being able to highlight the color of patches that come in e-mails, special thanks go to my friend Adam and Karel Zak's blog post:

If you are a heavy GitHub user, this is IMHO where mutt shined as being highly customizable, you can set your color scheme to highlight diffs coming in an e-mail, for example look at the following screenshot where the patch in which I made a comment is now colored in green for the additions:

These are the lines in my configuration that make this possible:

# diffs coming from github, thanks to @adamrp, for making this work better

color body green color234 "^(\>\ )*diff \-.*"

color body green color234 "^(\>\ )*index [a-f0-9].*"

color body green color234 "^\(\>\ )*\-\-\- .*"

color body green color234 "^(\>\ )*[\+]{3} .*"

color body brightgreen color234 "^(\>\ )*[\+].*"

color body brightred color234 "^(\>\ )*[\-].*"

color body cyan color234 "^(\>\ )*@@ .*"

I've been using my e-mail via mutt for the past two days and I have to say I cannot be happier.

[yoshikee]

Statwittstics, a data analysis journey

In this blog post I am going to talk about a program that I wrote, initially motivated and conceived as a consequence of my curiosity to see what my twitting activity had been in the past few months. I was curious to see at what time of the day was I twitting the most, which days was I twitting the most, etc. So I came up with Statwittstics.

In a nutshell what I wanted to do with Statwittstics was to have a dashboard to ask questions about the activity of a Twitter user and do this in a very interactive way. At the time I looked for existing solutions, but none of them seemed to fulfill what I was looking.

Finding a way

I had an idea and I knew what I wanted, but just like with many other things, I didn't know how to implement any of what I wanted nor I was sure if I should be doing this. Oddly enough I came across a talk from Apple where they go into detail about blocks in Objective-C, a feature that at the time was novel and had a lot of interesting use cases. I watched this talk and was intrigued by the power of blocks, so as I was searching through the catalog of talks in the developer resources at Apple's Developer Portal, I found a talk about Twitter's native API for iOS. I watched the talk, what a great talk, and followed along with the examples. As I completed one of these demos the following thought struck my mind:

Hey ... I could write that Statwittstics thing in Objective-C, and have it be an iPad app, this in turn might be useful for social media managers who are interested in tracking their "performance" or just for curious users.

I was excited, this seemed an excellent opportunity to:

Dive into using blocks.

Doing some relatively simple data analysis.

Writing an iPad application (I had done this before but never one that was not trivial).

Having a pet project that I could devote time whenever I was bored.

I kept playing around with the cool things that the API allowed you to do and as I did my amusement kept growing and growing. I was sure that this was going to be the right way to make Statwisttics come to life.

A familiar sounding name

With technical curiosity now being the main driver that I had at the moment, I started looking for ways to take care of the visualization capabilities (my initial intents were rather simple) that I wanted Statwittstics to be capable of. Some googling around lead me to a few projects that were capable of making pie charts, scatter plots, etc, but none that was an actual plotting framework with a well thought API.

Luckily for me a post in StackOverflow lead me to Core Plot, which at the time was hosted in Google Code, this was a great solution. Core Plot was a mature, active and well supported open source project, needless to say, I was extremely excited.

As I dug around some of the examples, I quickly realized that I had read before about Core Plot, and not only that, I had even tried out some of the demos and was pretty happy with them. This was great, Yoshiki from the past had already approved this framework.

I searched for a couple tutorials to get a better understanding of what was going on in the examples, started playing around with some of them and started creating some of my very own plots.

Core Plot is carefully well designed and feels a lot like the way a plotting framework would be structured if Apple authored one. Regardless of this, programming a plot always requires a lot of code, why you ask? Well because if you want to have control of how you want to display the data, you are going to need to customize a variety of parameters, this seemed boring but I kind of embraced it and wrote a set of wrappers to do what I needed, I called it the PBKit.

Assembling the pieces

Now that I had the plotting backend and some of the basic functionality to retrieve twits from a user I knew I had to start prototyping the user interface. At the moment I came up with a really simple one-screen app that would load the data for a user (the owner of the iPad) and plot it.

To start my prototypes I decided to use OmniGraffle, and a set of stencils designed for rapid prototyping of iOS user interfaces. Using OmniGraffle I started thinking more on the type of things that I could add to the screen and the things that would be handy to have so the few things I came up with were:

Main Screen: a simple screen with a summary of the user bio, a plot of the selected activity and some selectors to choose what to plot:

Plot Manipulation Actions: I wanted the user to be able to see what the data that was being plotted was, so I wanted to be able to show a (a) cross-hair kind of thing as the user touched the plot. Alongside with this I also wanted to be able to see the twits that were composing a data point (b):

a

b

Statistical Stalking Searching: A new screen would show up if you so decided that you didn't want to look at your own data but that you instead wanted to look at the data from another user, the first thing you would need to do would be to go to the user menu on the right (a) and then search for the username you wanted to gain an insight into their twitting activity:

a

b

In retrospect this was probably the most important part of this project, as I was not very familiar with the available widgets for the iPad iOS and I didn't really know how would this end up looking; hence I wanted to avoid programming the way Bret Victor defines it:

Programming is blindly manipulating symbols

The birth of Statwittstics

After a couple weeks I came up with a functional version of Statwittstics, it was working, I was able to use it and I was having a lot of fun using it, needless to say it was buggy and rough around the edges. As I continued working on it and adding more functionality (sharing on twitter, selecting which user you want to log in as), I knew there was something lacking, something quintessential to any project: a logo.

I contacted my good friend and graphic desginer Ana, explained her my idea, of course she told me: "You are crazy that's a weird thing to do ..." but she agreed that in some of her spare time she would work on a logo for Statwittstics, I was thrilled and excited. The result:

After a couple weeks I had already finished the initial prototype with all the functionality that I wanted, the program was "stable" and was usable. I was extremely happy with it. See for example the implementation of the main screen at an early stage:

And then an updated version a couple weeks later, with a few extra controllers:

And of course we had to be able to share these sweet plots on twitter so hence the following:

And this is how searching for a user looks like:

If you are curious about this and more, I've made the code available on GitHub, you can find it here:

http://github.com/ElDeveloper/Statwittstics

I encourage you to try it out, depending on when you try it out, you might find that some settings in Xcode have changed so, please let me know if this is the case so I can update this.

[yoshikee]

Mechanical Typing

Over the past few months I've had to use my keyboard more than I've ever had before, of course I had no issue doing this because I was enjoying every second of the crafting, tinkering, advancing and discovering that my typing usually involves; everything or almost everything I've been doing requires a keyboard and/or a mouse.

On busy days all the fun that I would get from typing would lead to pain on my forearms and hands, not the type of pain that you have after exercising a part of your body at the gym but a type of pain that get's to be hard to ignore, even to do the most simple tasks. This pain became a huge limitation to my creative process.

After talking to my mother and father (both health experts) they suggested me to look for a more ergonomic peripheral or to just plain stop typing or I would really screw up my wrists and or fingers due to severe pain, muscular atrophy, etc. So I started looking for such a thing and the first thing I came across were these really odd shaped keyboards:

A weirder one:

I even got a chance to try one of these when I was visiting a friend in NYC but I didn't like it at all, plus the fact that this would make me dependent on that specific shape to feel comfortable which for once was never going to be found in a laptop and not to mention that it's very unique form would definitely change the way I type make it extremely uncomfortable when not typing in this keyboard (this is a consideration I had to make given the way I work i. e. everywhere/anywhere).

Then I came across the CODE Keyboard (see below) which my parents even offered to buy for me as a present as I was being very indecisive about whether or not I should be buying a keyboard like that, of that price range without even trying it out (the CODE keyboard priced at 150 dollars). Before I knew the keyboard had sold out.

As I was lurking WASD keyboard's website (the makers of the CODE keyboard), I found out that they provide a plethora of ways to customize a keyboard, from keycap colors, switch type to the print in each of the keys. So one saturday morning at 7 am, I decided to open Adobe Illustrator and start the design of my custom made keyboard. The end result, what I decided to call the Y1:

The main idea of the keyboard is to show the hexadecimal representation of the ASCII characters for all the symbols but for the letters a-z and for the enter key and tab key, which I decided to use '\n' and '\t' respectively. They keyboard has Cherry MX blue switches and needless to say, it's loud. But it is also an extremely comforting typing experience. I couldn't believe how pleasing it was to type in a mechanical keyboard, my reaction was such that I had to carry this from home-work and from work-home on a daily basis for a good two weeks, then I got tired of doing this and decided to buy another keyboard.

Initially I wanted to buy the exact same keyboard, but I couldn't find a way for WASD to get it in a reasonable time (less than 4-5 months). Hence I decided to go with the Das Keyboard for the Mac:

So now I have the WASD keyboard at work and the Das keyboard at home. After switching to this new world of clicks and clacks, I have to say: I'm an extremely happy costumer. And lastly if you ask me: "Is the price worth it?" I will respond: It is worth it for me, working on these keyboards gave me back the freedom that I would usually get from typing and added an extra comfort to it.

[yoshikee]

Contextualized Timeline of Sequencing Cost

Earlier this year I came across a tweet from Thea Whitman where she drew a contextualized version of the increasingly reduced costs in sequencing technologies as reported by the NIH. This plot is widely used in presentations commonly when the presenter is trying to make the point that sequencing is very cheap now as compared to previous years and that this trend has a much more steep slope than Moore’s law.

Whilst this is a useful graph and mainly communicates two really important ideas, it is a figure that a lot of people use and if you are at a meeting where there are several presenters, chances are you will see this plot a few times.

Fast-forward to a couple months later, I found out that Matplotlib is capable of producing XKCD-like plots i. e. the plots will look hand-drawn.

Hence with these two things in my mind, I decided I should be able to recreate the drawing that Thea made to hopefully provide an alternative to NIH’s original plot:

I decided to do this using the IPython notebook given that it is an extremely useful tool for prototyping, analysis and processing (among many other things). With the IPython notebook, it’s easy to share code and plots in a unified document; hence I created the following repository with the notebook itself. If you want to take a look at it see this link.

[yoshikee]

How I tricked Wolfram Alpha with Twitter's API

This is the story of how I tricked the marketing team of Wolfram Alpha back in 2009, more specifically the social media group that was in charge of a campaign called Holiday Tweet-a-Day. The idea there was that at a random time during the day, these guys would post a tweet, which had to be retweeted as fast as possible and the first person to do this would win something. So I tried a couple times, this was a boring and tedious process and the only time that I got really really close to do this was when I saw the tweet on my phone and immediately tried to re-tweet it, but I couldn't, because I was not fast enough using my touchscreen.

So I got tired of this specially because it was a really tedious and boring process, but I got to a point where it almost felt like a challenge, luckily for me, earlier that year I had taken Stanford's CS193P class online, in this course you learn how to use some of the key Frameworks in iOS to create usable mobile apps. Through this course you also learn how to create a bare-bones twitter client, which was able to tweet, read tweets and a few other things. So I decided to write a small program to pull down all the data from the guys at wolfram and re-tweet as soon as it could.

The program is not even 150 lines, since I had no desire to make it clean nor pretty it didn't take me long to write it (perhaps 30 mins or 20 mins). In short this program would pull down @Wolphram_Alpha's twitter timeline, and check if there was a new tweet that could be re-tweeted, if it found a new tweet it would immediately create an post a new tweet from one of my two Twitter accounts.

So I started the program checked on it for about 5 mins and then left my computer, I think I had dinner with my family then when I went back to my computer, the logs showed that it had posted something already. First thing that crossed my mind was "I probably screwed up and this program is not working correctly", so I decided to check what happened  and I realized that it had indeed found a new tweet and successfully re-tweeted it. A few minutes later I received a direct message from one of the guys of Wolfram Alpha.

They kindly sent me a Wolfram Alpha spikey and a Wolfram Alpha shirt. I was super happy and exceedingly excited but not because of the gifts themselves. The reason why I was so joyful was the fact that I was able to effectively automate a process that some could argue did not need to be automated. At this point I was finishing my second year at engineering school, so this was one of my first few approaches where I was able to see myself crafting a solution that immediately had a personal benefit.

Just in case you are wondering, this is the tweet that made me a winner that day:

RT: @Wolfram_Alpha #WolframAlpha Holiday Tweet-a-Day: Here one more reason to not feel guilty about not eating that fruitcake: http://bit

— Yoshiki (@yoshikiv)

December 27, 2009

And if you are curious about the program, I have uploaded it to GitHub and you can find it here.

[yoshikee]

Sublime Text

I’ve always said that if I could marry a piece of software, that would probably be Altium Designer (a next generation electronics design program), there’s no easier way to go from an idea to a hardware design than this beautiful integrated development environment. It incorporates multiple aspects of the design and implementation into a single and consistent user interface. Their documentation is extensive, clear and professional.

The program is targeted for professional level applications and is one of the most stable systems that I’ve ever used (note that this program only runs on Windows).

I spent a long time using Altium as an undergrad and I got the chance to design and fabricate a variety of boards, going from an schematic to a real board cannot be easier. I've tried some other programs similar to this one, but none of them were nearly close to the mature state in which Altium is.

The reason why I’m talking about Altium is because if that’s the program that I would marry, Sublime text is the program I would cheat on Altium with. Last year I got to a point where I realized that I needed a multipurpose text editor that I could use, I already had a bunch of them (TextMate, VIM, Emacs, TextWrangler, nano, pico, Coda) installed in my computer but none that I could use on a daily basis efficiently. So I embarked on a search for a good text editor that could fulfill my needs, it had to be fast and be very lightweight with support for as many programming languages as possible.

On this journey, I tried a few of them for short periods of time. As a long time Xcode user, I of course tried to force myself to use Xcode for everything that I needed to do, however it is nearly impossible to use Xcode as a multipurpose text editor. If you want to quickly edit a plain text file you’ll fell like you are using a bazooka to hammer a nail. Python support is not that good and really the thing that it is the best for is Objective-C programming (hands down).

The next one was Coda, one of the thing that I loved the most about Coda was it’s FTP integration, it’s close to magic, though I have to say that I do not like at all it’s lack of low-level customizations. I tried Coda 2 and got a similar feeling.

I was lost and wandering around without an editor, then I came across a blog post talking about Sublime Text, my first thought was: "Sublime Text is a stupid name for a text editor" (I still believe this). However the first thing that I was amused by is it’s general purpose auto-completion, the next thing that caught my attention was the huge catalog of plugins and customizations that you can have with the program.

After a lot of testing (some could say usage) I ended up adopting this program and can say that now, getting close to a year and a half, I’m still happy with it.

One of the downsides is that I spent quite some time trying to make it look like Xcode. The first thing was to emulate the syntax highlighting, lucky for me someone had already done this for TextMate and guess what! Sublime Text is compatible with Text Mate’s color schemes. All I had to do was to tinker it a little and I came up with something that I felt more comfortable with.

A couple weeks ago the guys at Sublime Text released Sublime Text 3, which works great and is definitely faster than it’s predecessor. it’s not until you are editing 20K lines files that you appreciate performance.

If you want an advice on how to select a text editor, my recommendation is to try them all, until you are convinced that you are making the right decision. Do not just adopt a text editor because "it’s the one that everyone at work uses", select a text editor because you feel comfortable with it and you feel it adjusts your workflows the best.

[yoshikee]

A co-worker originally sent this article to me last week, I just had the ten minutes to read the whole text and I have to say that, it's an intelligible source of general knowledge about terms, problems and goals that computational biologists deal with everyday.

Definitely worth a read if you like the topic or if you are not familiar with the field and would like to delve a little more into it and see "what's all the fuzz about it".

[yoshikee]

GitHub announced they are removing the downloads tab from every repository, this brought the problem of not being able to share a static link to provide users with a download. Therefore this post exists, to be the reference place to find the download link (for now) to the latest build of Macfusion.

[yoshikee]

Launch Services

In my humble opinion, Apple has a very unique and beautiful way to create software, however some of their APIs are not so easy to understand at a first glance, still very robust and reliable. With this in mind, there have been a couple times where I have found myself misunderstanding what the documentation was intended to communicate and therefore it is usually my fault when something is not working how it is supposed to. 

That being said, I had a very unpleasant experience last weekend when I was learning about the Launch Services within App Kit. One of the things that Launch Services is good to, is to have an application interact with Finder or with the Login Items of the system, something pretty cool and useful. Everything was going well, and I was able to programmatically add an item to the Finder Sidebar. So once that was done I was happy, but then I thought that it would be cool to add an icon to that item and oddly enough I found out that the current function I was using to add the item had an option to add an icon, so I proceeded to add the icon, but it didn't work at all. And I continued to try and try and try, without any luck.

Once my pride was in the floor, I realized that the all-mighty internet should already have an answer for this, so I found the following sources of knowledge:

How to get Finder sidebar favorites content cocoa?

How do you programmatically put folder icons on the Finder sidebar, given that you have to use a custom icon for the folder?

And I tried some of the suggestions, I tried different ways but I couldn't get a custom icon to show with the item in the Finder sidebar. I finally found a thread in the Apple developer forums with a user mentioning this has been reported to Apple's bug tracker Radar. 

Given this my conclusion was to just let this go, though then I found that Radar bugs are taken into account given the number of reports posted in the tracker, so I Issued a bug, let's hope for this to be solved sometime soon.

[yoshikee]

Macfusion on OS X Lion 10.7 and Mountain Lion 10.8

A few days ago I was about to install Macfusion, which if you don't know already, is a great project that aided by the FUSE project or rather the macintosh port MacFUSE is capable of providing support for users to mount filesystems over the network. It is all good and both projects are open source but the problem is that as far as I know the software is only supported for 10.5 and 10.6 i. e. Leopard and Snow Leopard. And even worst not even MacFUSE is supported as it has turned into abandonware.

Using Macfusion in OS X 10.7 Lion is rather painful, a few bugs here a few bugs there, but some of them are fixable by the regular user, which now have to rely on OS X FUSE and SSHFS two projects that are in active development.

Doing some quick google searches I was able to solve a few of the issues, still some other issues were still there, so I decided to take a look at the source and I realized that there is a bunch of people who have identified the same issues using github's network feature and even more awesomely they have fixed them.

So this is a call to everyone and anyone who find this project useful and want to try to bring it back up. I have made a few modifications on this repository, be sure to see the commit history to see a detail of the modifications.

[yoshikee]

Code Poetry

I have had the chance to work with quite a few programmers and with quite a few programming languages. I have done this with the following purposes:

Recreational.

Educational.

Commerical.

No matter what the programming language, the purpose, how big the team is and who you are working with you must always care about the documentation of your code. This is not an official classification about code documentation, but these are the most common types I have seen and probably the most common ones:

/*Comments*/

def identifiersWithinCode(amount):

Documents & Diagrams

Doodles on a white board

/*Comments*/ or #Comments or //Comments or %Comments or <!-- Comments -->

In my humble opinion this is one of the most important types of documentations that should be done, there is no excuse not to have them. This type of documentation is (probably) like an investment, sure, it takes some time to describe what you are doing, but trust me, if you come and look back at your code in 4 months it will be most likely that you won't remember how did you solve everything with your code. And if someone has to give maintenance to that code, this is probably the easiest way to for them to understand it. This way you will avoid having someone bugging you to explain them your code.

Sometimes you can even find bugs by just reading your comments, or in another case, someone else can find flaws.

What you should do:

//i has to run outside j, otherwise epicMatrix won't be filled with the data

//and if you don't get the value of amazingVector times the position you will

//probably get uneven values

for(i=0; i<LIMIT; i++){

    for(j=0; j<LIMIT*CONSTANT; j++){

        epicMatrix[j][i]=someValue[i]*(amazingVector[j]*j)

    }

 }

 What you shouldn't do:

//Print an error

printf("Error:You cannot divide by zero\n");

def thePoetryBehindMeaningfulIdentifiers(inCode):

People do not often pay attention to the importance of having meaningful names in their variables, in their functions, in their modules, in their classes, etc. Why would you even care about this? Because again you are probably not just working for yourself, people often re-use someone else's code and when they do the last thing they want to do is read enormous amounts of code to understand how to use some API/Library. If you name your "stuff" in a meaningful way, it will be easier for others to understand your code.

But it's not just about names, it is also about the way things are typed, different languages and even between different frameworks (within same languages), you will have different ways to type things.

The underscore: This one is in my opinion the easiest to read, though it is very uncomfortable to write, specially if you are not using an awesome text editor that will complete your function names. The first example that comes to my mind is C, specifically in GTK+, you will often see the following:

GtkWidget* gtk_button_new_with_label(const gchar *label);

The Camelcase: My personal favorite and one of the most annoying ones for some others. An example for this one is Objective-C, where a method call would probably look like this:

[someString stringByReplacingOccurrencesOfString:withString:@","];

The Creative Bastard (TCB): Again, this is no official classification, but this one seems to be the way to call it. This is no obvious way to name a function, IMHO, not the best way to name something, it probably is good for functions you use on a regular basis. An example, any of the command line tools found in UNIX, for example cd (change directory), mkdir (make directory), prstat (process status), among many others. One commercial use I have seen of TCB, is by The Mathworks Inc. current sellers and developers of MATLAB, for example:

dec2bin %convert a number from decimal to binary

tf %transference function

pzmap %pole zero map

Documents & Diagrams

This is to me the most annoying one to do, though one of the easiest ways to explain yourself (of course if you can :P). Suppose you are developing the most awesome algorithm ever to detect faces in a picture, depending on who you are, what you are doing it for, where are you doing this and why are you doing this, you will use one platform that suits you better, for this example let's suppose it's C++ running on a desktop. So you are writing your code but you feel the need for feedback and sure, one of your best pals has a Ph. D in Electrical Engineering and his thesis was about digital signal processing, so you ask him, but he doesn't know anything about C++ ... he probably won't be able to help you, even with just comments on the code will probably be hard for him. The solution, a document, if you write a clear enough document explaining what your code is doing, explained with some diagrams, he is surely going to give you a hand.

Doodles on a white board

Don't ever rely on this one, this is more of an honorific mention. The value of making a doodle of what you want to do hides behind the idea of a group of people (say the user interface design team) working together refining an idea in an accelerated and not limited way. 

Sure you might say, who ever uses white boards, you can do this with OmniGraffle, send an email and there, it's solved. Yeah, I agree, you can but you will have to wait for everyone to catch on the mail blast, so they can all put their ideas out. That's the biggest reason why a board rocks! Everyone can sum to the idea batch and refine the final product/prototype easily and quickly enough so that someone in the team can Omnigraffle the shit out of the doodles and add it to a document ASAFP.

Conclusion

Try them all, encourage your co-workers/friends to use them.

[dndeuce]

So, Michael Jackson has a song called 2000 Watts on the “Invincible” album. I think it was actually written by Tyrese though. In the chorus, he gives us some figures (see figure and attached video). Because I am slightly nerdy, I have decided to check his math/measurements. I conclude that both Tyrese and Michael Jackson would be terrible electrical engineers. These are things I do when I’m supposed to be doing homework.

Appendix A: The song in question

[yoshikee]

Reminds me of XKCD's http://xkcd.com/643/

[yoshikee]

Bowers & Wilkins P5 (frequency response)

I know, I have already written a post about the Bowers & Wilkins P5 headphones, they are good, no doubt, I totally recommend this to you for further details read the full blog. Now the only thing I have found (quiet often), are wannabe audiophiles who claim this headphones have great mid-ranges or that this headphones have a bad bass and what not. I don't like to guide things by opinions but by facts, therefore I present you a small analysis of the frequency response of the Bowers & Wilkins P5.

First thing first, if you are not familiar with the terms and all the jib-jab, don't confuses the frequency response with the frequency range or bandwidth. I have even seen quiet a few audio product related manuals confusing the frequency range with the frequency response. I would probably blame translators and not the companies themselves.

When it came to my mind that I wanted to analyze this headphones' frequency response, the first place where it occurred to me to look for was at the B&W site and I could not find such thing there. Then I decided to contact their support team, after a day (that was fast), someone came back to me, pointing at this review by PC Magazine. 

In that review, they present a frequency response chart, comparing the B&W P5 with the Grado GS1000 (Fig. 1) and another frequency chart comparing the response of the two channels (Fig. 2).

Figure 1. Frequency response chart comparison between the Bowers and Wilkins P5 and the GRADO GS10000. In the x axis the frequency in Hertz and in the y axis the magnitude in decibels. 

Figure 1. Frequency response chart comparison of the two channels of the Bowers and Wilkins P5 and the GRADO GS1000. In the x axis the frequency in Hertz and in the y axis the magnitude in decibels. 

If you know something about signal processing you are probably wondering, where's the test signal, what was the sampling frequency of that signal (probably 40K), what was the output impedance of the player used for this test, what's the frequency response of the transducer used to perform this test, what was the window used to estimate the transform. Wonder no more because there is no record of that data and you know what, probably not even PC Mag will be able to answer you this questions, they probably don't even know or care about those things. That's why I got back to the B&W support team and they told me that they didn't have the data, that I should request the data to PC Magazine.

Now, you would wonder, why would you care about all those things? well because if you don't care about those things, you aren't really doing a good frequency response analysis, you are just performing the Fourier transform to some data.

Anyway I kept looking for a more serious analysis and I found out that Inner Fidelity wrote a very complete blog reviewing the B&W P5. There your will find another frequency response chart (Figure 3). I have already requested the data of both of the sites, if any of them provide me with the appropriate files, I'm willing to do a much more exhaustive analysis of the frequency response, I will write the software that's necessary for such purpose.

Closing statement

What do we learn about this? Do not trust a freaking audiophile telling you shit about headphones, trust the data and trust the controlled data only. In the end what's more important is not the fancy charts, the real important thing is that you like what you buy.

BTW and if you didn't already know, Fourier is awesomesauce! 

[yoshikee]

JVC (HACN80) VS B&W (P5)

That's right, I'm going to compare a set of JVC and a set of B&W headphones.

Audiophiles are probably already saying something like: "The clear winner will be Bowers and Wilkins, there's no chance for JVC to fight back". But you know what, I don't think I have any audiophile readers, so fuck that.

Anyway, direct your attention to Table 1, the first thing you will notice is the price, it is almost an order of magnitude of difference. ¿Should this be the indicator that one is better than the other? I don't think so, I don't like to use the price as an indicator of quality(although most times it is).

Table 1

Now, what qualifies me to compare this headphones? Well, I have them both, I like them both and I have some spare time to write this. Table 1 should only serve you as a quick way to compare both of this pieces of hardware, you must decide what are the features that you want in your headphones.

Cons about the JVCs HACN80:

Made almost entirely of plastic.

The impedance in the off mode is not the best match for an iPod/iPhone/iPod/¿Zune?.

They apparently look goofy (this is a common comment I get).

They fall way too much from your head, unless you are still and not shaking your head a lot.

Pros about the JVCs HACN80:

They are extremely under-priced for the quality they provide.

They are a good buy for music lovers (not for snobs).

The noise attenuation is really good for the supported bandwidth (obviously).

You have no idea how comfortable this headphones are, no idea. You can wear them for about 4 hours without feeling any pain.

Cons about the B&W P5:

They are not cheap.

They are not so comfortable after long periods of time (after 1 hour you will feel a bit of pain in your ear).

Pros about the B&W P5:

They are entirely made of leather and metal, which should last more than just plastic and vinyl.

Although the P5s are not active noise attenuation headphones, they do a great "passive" job blocking a lot of the outer noise.

They are esthetically good looking, they don't look as goofy as the JVCs.

The controls for the Apple products work as expected and are handy for Skype/Facetime calls when you are using them with your computer.

The sound quality IS FUCK-AMAZINGTASTIC-KICKASS, they are not bass punchy like the Dr. Dre's headphones and are not plain as most headphones, they provide a good balance for most frequency ranges, though I have yet to find a bode plot for the frequency response to be sure about this.

Conclusion:

This is just a way to put face to face two pieces of hardware, I like them both. If you are about to pick a new pair of headphones, be sure to try them first. Although my opinions are extremely awesome, you can't trust we both will react the same against certain features. Some people like their headphones only because they have punchy bass, some people can't stand leather, some people just hate certain brands.

Although I like how the P5s sound, I hate how uncomfortable they are. I hate the fact that my JVCs are made of plastic and that they are (to some extent) fragile.