Francisco Soto - ebobby.org

Scratching your own needs and open source

2012-05-20T00:00:00-07:00

Scratching your own needs and open source

20 May 2012

I’ve been thinking recently about how hard it feels to contribute to an open source project and by that I don’t mean that open source makes it hard for you, au contraire, some of them try to make it as easy for you to do it as possible, sites like github, codeplex, google project hosting, etc., give you and developers the tools to build an open source project and try to foster a community around it.

I think one of the main motivations people have to contribute for creating and contributing to open source projects is having a need. You need something and you simply do not find something that solves your need in the market (or you can’t pay for it) and create an open source project, or maybe there’s a project somewhere that almost solves it and it just needs a little push so you contribute. You need to use it to be able to be an effective contributor, and most of the time, you use it because you need it.

You can find a lot of examples of this but the canonical example is Linus Torvalds starting Linux because he wanted to run Unix on his 386 and his only option at the time was MINIX and he was frustrated by its licensing.

Nowadays of course, most people don’t have a need to build an OS from scratch (do they?), so they build other fancy things like Redis or Ruby On Rails which again, were started to scratch a need and people have been adopting in en masse because they had that pain too.

Funny thing is, we look at these examples and think that a successful contribution or a successful project has to be a complex piece of software that solves the needs of millions, or contributing to a project involves being a genius, nothing far from the truth, lots of open source projects thrive with the contributions of every day developers like you and me caring enough to research a bit and be interested in helping.

When I was in college, a few years ago, I used FreeBSD on my personal computer which was a bit of a problem because the school machines and my professors used Windows machines. So when I was developing something (mostly in C back then) it had to compile and be able to run in Windows. For the most part this isn’t very hard to do if you stick to ANSI C which suffices for most of your average school projects. That is, until you try to do something fancy…

As part of my AI class, we analyzed several combinatorial optimization algorithms and tried to solve different problems with them, one of the problems of choice was the 8 queen puzzle which basically consists on coming up with arrangement of 8 queens in a regular chess board so that no two queens can attack each other.

At the end of the semester I decided to present as a final project a version of all the algorithms we saw trying to solve this problem but instead of having only print outs of numbers or strings as a solution, to actually have a 3D chess board and the queens moving from place to place as the algorithms worked on the problem so it would be more visual and more interesting to look at. I coded this using C and OpenGL under FreeBSD and since I needed to compile it under Windows too I used GLUT to handle my windowing and input needs.

The way I went was using the Mesa 3D library which at the time was at its 5.* version, but in FreeBSD’s ports the available version was 3.* (called Mesa3) which for some reason would not work in my machine, the window opened and the program ran and I got output on my terminal but the display would be always black and I struggled with this for a while but it really pissed me off that with a hand compiled current (at the time!) Mesa 5.* version it would work flawlessly.
The reason it pissed me off is because I have never liked manually installing things in my *nix systems, if you want to remove them you have to look for the files, read the Makefile, etc. I always try to use the package manager or I feel my system as “unclean”.

So, in order to be able to use Mesa5 and still feel somewhat clean was to make it a package, so I did, I copied the Mesa3 port directory to a new Mesa5 directory and changed the Makefile (and I do not remember if I had to change the patch files a little bit too) to work with Mesa 5.*. I got my project running, able to compile correctly under FreeBSD and Windows and got an A+ on my AI class.

I also sent the files to FreeBSD (I do not recall what medium I used), I thought they were going to ignore them and I thought they did because I never actually got an answer.

Here’s the kicker, years later, as I was googling around my old email address for reasons I do not remember, I found out a series of emails about my commit!, they actually received it and considering making me the maintainer of a newly created mesagl port (mine was called Mesa5 I guess mesagl was created by another guy with my same problem) until another guy came with another update that was better. I never found out when it was actually happening because I wasn’t in the mailing list (which is one of the first things they ask you to do if you are going to commit stuff, my mistake).

So that’s the way I almost became a FreeBSD port maintainer. Maybe if I go back to FreeBSD at some point (using archlinux now) Ill try to get to maintain a port.

Structure and Interpretation of Computer Programs

2012-05-02T00:00:00-07:00

Structure and Interpretation of Computer Programs

02 May 2012

With my recent motivations to learn Lisp, I’ve been feeling reconnected (or finally connected) to what Computer Science is really all about. This has given me a new interest in picking up on my math again and learn properly all of the math I should had groked back in college. The math that gives you the tools to be a better programmer, computer scientist, and thinker in general.

In order to start this and get the ball rolling, I am going to (finally) read Structure and Interpretation Of Computer Programs, this book has been in my shelf for a few years and I never actually got to sit and read it thoughtfully, maybe I wasn’t ready or maybe I am not smart enough to read it, but I will give it a serious shot this time, and as I work through the exercises, I am pretty sure I will be having to consult and read about math, since at least the first chapter exercises seem to be mostly math related.

I created a Github repository where I will be putting the source code of my solutions to the exercises in case you are interested in them.

After this I would probably tackle as many exercises in the Euler Project as I can, that will certainly be a good exercise in coding and mathematics in general.

I will be definitely writing about how I do and what I learn and the pieces I find most interesting as I go.

Exercises:

Chapter 1

1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 1.10, 1.11, 1.12, 1.16, 1.17, 1.18, 1.22, 1.23, 1.29, 1.30

Chapter 2

Huffman encoding trees

Lisping and the word ladder puzzle

2012-04-18T00:00:00-07:00

Lisping and the word ladder puzzle

18 April 2012

I want to talk about Lisp because so far I can say that I am really loving it and I will certainly be spending more time with it and learning about it.

Allow me to quickly tell you about a little nice puzzle:

Word ladder Puzzle

This puzzle was invented by Lewis Carroll a long time ago, the puzzle is defined by three elements, a language (for our purposes a dictionary with plenty of words of the same length), a start word and an end word. The goal is to find a path between the two words by changing a single character at the time, and the resulting words from such change have to be valid words in the given language.

Example for HOME and MEAL:

HOME → HOLE → HOLD → HELD → HEAD → HEAL → MEAL

Solving it

So, armed with my new rudimentary skills of Common Lisp I decided to write a Lisp solver of this puzzle. The code is in Github, along with a ruby implementation I wrote a while ago. I will reproduce the Lisp version here in order to explain the way I solved it, maybe I can pique your interest and you want to learn about it too.

First, we have to have some dictionaries handy, I already have some up in github that you can download. Now that we have a nice dictionary, we have to read it and have it handy, in Common Lisp:

(defparameter *dictionary* ())

(defun read-dictionary-file (fname)
  (with-open-file (stream fname)
    (loop for line = (read-line stream nil 'foo)
       until (eq line 'foo)
       collect line)))

(defun initialize-dictionary (fname)
  (let* ((dictionary (read-dictionary-file fname))
         (first-len (length (first dictionary))))
    (setq *dictionary*
          (remove-if-not (lambda (word)
                           (eql (length word)
                                first-len))
                         dictionary))))

The first line simply defines a global variable named *dictionary* (the * around the name is a naming convention) to be an empty list. Then we declare two functions:

read-dictionary-file: Opens the file with the given filename, reads every line and returns them as a list.
initialize-dictionary: Calls read-dictionary-file and stores the given list in a local variable, then it gets the length of the first word in the dictionary and removes every word from the list if its length is not equals, a basic check, finally it saves the result into the *dictionary* global variable.

If you have a flavor of Common Lisp installed, we can already test this functions in the read-print-eval-loop (I am currently using clisp):

[10]> (initialize-dictionary "dictionaries/four-char-dictionary.txt")
("mitt" "that" "with" "they" "this" "have" "from" "word" "what" "were" "when"...

[11]> *dictionary*
("mitt" "that" "with" "they" "this" "have" "from" "word" ...

[12]> (length *dictionary*)
923

Now that we have our dictionary handy, let’s think a bit about the problem. We want to find a way between two given words, we start from one word, how do we know what our options are to move from a word to another?

A way to visualize this problem is as a graph, where every word is represented as node and the edges connect nodes which are apart only by a single character.

For example, in a dictionary with english words of four characters, the word “home” has the following neighbors:

Here’s the code to find the neighbors of a word in our dictionary in Lisp:

(defun one-apart-p (w1 w2)
  (and (eql (length w1) (length w2))
       (= 1 (loop
               for c1 across w1
               for c2 across w2
               count (not (equalp c1 c2))))))

(defun find-neighbors (word dictionary)
  (when (member word dictionary :test #'equalp)
    (remove-if-not (lambda (x)
                     (one-apart-p word x))
                   dictionary)))

one-apart-p: It’s a predicate, that is, it returns true or false. It is a convention in Common Lisp to suffix predicate functions with -p. What it does is that given two words, it loops across them counting how many differences they have. If they have only one difference it returns true, else false.
find-neighbors: Takes a word and a dictionary and returns a list of all the words in the given dictionary that are one character apart from the given word. All its neighbors!

Running the code:

[61]> (find-neighbors "home" *dictionary*)
("some" "come" "hole" "hope" "hose" "Rome")

Now that we can find the adjacent words for each word in our dictionary, we can find our ladders. There are two basic ways to traverse the graph, which are:

Breadth-first: We check the current level before moving onto the next one, that is, we check if our target word is in the neighbors list, in our example, home to meal we check if meal is in the neighbors of home, it is not so the next step is to move one level down, we do this by having a list of all the neighbors of the neighbors (recursivity), then we check again, if not we move down another level and so on. Wikipedia
Depth-first: We get our list of neighbors, then we check against the first one, if it is not our target, we get its list of neighbors, check against the first one, if not we get its list of neighbors… you see what I mean, basically, you go as deep as you can in the graph, if you hit a dead-end you go back to a level where you have more neighbors and then you go deep on that too. Wikipedia has some nice animated gifs showing how this works. Wikipedia

In my implementation I chose breadth-first, is way faster than depth-first for this particular problem, other problems may be better served by a depth-first approach.

The code:

(defun find-ladder (first second dictionary)
  (labels ((follow-ladders (ladders visited)
             (let ((already-visited (nconc visited
                                           (mapcar #'first ladders)))
                   (matching-ladder (find-if (lambda (ladder)
                                               (equalp second (first ladder)))
                                             ladders)))
               (if matching-ladder
                   matching-ladder
                   (follow-ladders (mapcan (lambda (ladder)
                                             (mapcar (lambda (neighbor)
                                                       (cons neighbor ladder))
                                                     (set-difference (find-neighbors (first ladder) dictionary)
                                                                     already-visited
                                                                     :test #'equalp)))
                                           ladders)
                                   already-visited)))))
    (follow-ladders (list (list first)) nil)))

A bit long, but basically we are given two words and the dictionary, we define a local function with the labels keyword, this allows the function to call itself recursively.

Our local function takes two parameters, ladders and visited. Ladders is a list of lists where the first element is the word to follow, the function also creates two local variables, already-visited which holds a list of the nodes we have already checked and matching-ladder which checks if there is already a complete ladder.

If the ladder is found then return it and we are done. If not, follow-ladders calls itself recursively by adding the neighbors of all the current words to our ladders, always checking against already-visited so we don’t follow the same node twice.

find-ladder basically calls the local function by creating a list with the first word and an empty list of visited nodes.

Running the code:

[62]> (find-ladder "home" "meal" *dictionary*)
("meal" "heal" "head" "held" "hold" "hole" "home")

And that’s it! A breadth-first solver for the word ladder puzzle.

Closing remarks

One of the first shocks for programmers like me, accustomed to imperative languages (at the time of this writing I do C# for a living) is that there are too many parenthesis, but then I realized (thanks to Land Of Lisp) that they are simply lists of lists (or trees). Lisp is very homoiconic, which is a fancy word to say that the representation of the program is a primitive type of the programming language itself, this has the natural consequence of Lisp being able to process Lisp code itself, which is the concept of macros (unlike languages like C where a macro is simply text substitution), in Lisp functions take values and return values (as in every language) but macros take Lisp code and return Lisp code.

I am really liking Lisp, I will certainly be using it as often as I can to solve anything I can get my hands on to improve my almost non-existent skills. Which, if you are an amazing Lisper, please do not be offended if my code sucks, I am trying to learn, feel free to send me an email with any suggestion you may have!

Which reminds me, I would like to thank Peter Seibel, author of Coders at Work and Practical Common Lisp because he took the time to look at my original code and give me some very useful tips after I bugged him on IRC (go read his books, they are great).

Thank you Peter!

I shall learn Lisp

2012-03-18T00:00:00-07:00

I shall learn Lisp

18 Mar 2012

I’ve been meaning to do this for a long time, finally get to learn Lisp, but for whatever reason I always end up procrastinating in this particular endeavor (and in others as well).

Everybody that already know Lisp say the same thing, that learning Lisp will forever change you as a programmer, this may seem over hyped but I truly believe such thing is possible, that learning a particular language can forever change the way you think about programming. I’ve felt such thing with a language I learned a long time ago: x86 assembly language, maybe not to the degree of Lisp, enlightening in the ways of computation, but I certainly have benefited a lot from my experience with assembly.

When I was learning to program, I wanted to make games, and I started learning QuickBasic, after some time I found it to be very slow to do anything interesting in the computer I had at the time (80386SX, 2MB RAM), the game coding community in QB back then suggested using a game programming library coded in assembly, there were many available (it was a very thriving community at the time), after playing with some, of course, I wanted to make my own, and CosmoX was born.

At first it had a very humble beginning but I found learning assembly and making my own graphic routines very fun, so I kept going and going, I began learning many intricacies of MS-DOS programming, like Expanded Memory and Extended Memory, I learned about 3D mathematics and added a matrix/vector math module using the FPU, custom “drivers” for the mouse/keyboard, so after a while, CosmoX got a bit popular in the QB community and some people/games began using it, talking about it, etc, it was a small community, but few times after that I’ve felt so much pride.

Now after all that reminiscence, the point at hand, I spent all those long nights learning assembly, crashing my computer and then trying to find what piece of code that was misbehaving (not an easy to do task when you are in MSDOS and a bad instruction meant a reboot), learning about how the machine worked, optimization, learning obsolete technologies (all this happened in 2000-2001) I was left with a lot of experience that may not applicable in every day work but it certainly helps.

Every line of code I write, in any language, C#, Java, C, even Javascript or SQL, I cannot stop thinking about the very metal of the machine. How is this language going to do this? How much memory is this going to use? How are the final instructions that the CPU is going to execute going to look like?

I’m forever cursed with X-ray vision into the innards of the machine and although I am no expert, I am pretty sure it certainly helps me write more effective code, code that benefits the most of the abstractions offered to me by my tools, because, most of the time, I know what the abstractions are trying to help me with, what they are shielding me from, and instead of blindly using them without a clue, I wield them effectively as I know what lies beneath them.

Armed with my faithful archlinux based netbook, Common Lisp, and a copy of Land Of Lisp I plan on learning Lisp.

I will embark in the journey of Lisp learning in order to get enlightening and understanding. I know about functional programming and some of its concept and I apply them in my day to day work using C# and Ruby. But I certainly do not grok it, I do not fully understand it and I do not like that feeling, I want to know, I want to understand, I want to see the light and join the ranks of the Lisp preachers and me too, be able to say to you, that if you learn Lisp, you will be forever changed.

Moved to San Francisco

2012-01-08T00:00:00-08:00

Moved to San Francisco

8 Jan 2012

Well, finally, me and my wife were able to make the move to San Francisco. We arrived just a couple of days ago, we are staying temporarily in an hotel on North Beach.
I am in love with the neighborhood, feels pretty safe, there are plenty of coffees, bars, and restaurants to go by. We’ve been hunting craiglist to find an apartment in this neighborhood, we hope we can find something not too expensive (although that word is quite meaningless in this city).

We tried going to some open houses down to Mission District, but as soon as we got off BART (on 16th st and Mission) and walked for a few minutes, we came back, I may be a big pussy but I didn’t feel very safe and it was 12pm. I wouldn’t be very comfortable with my wife walking down those streets alone or at night.

Tomorrow I’ll be finally working at the office, is incredible that I’ve been working for this company for two years and few months and I still haven’t worked in the actual office yet, being an independent contractor from Mexico and all. I am becoming a full-time employee because of the move of course.

I can’t wait to finally get settled, and start hunting for coding-oriented events, and start meeting people and places.

All text Linux

2011-12-13T00:00:00-08:00

All text Linux

13 Dec 2011

I bought an Acer Aspire One D255E a few months ago. I wanted a netbook for very specific reasons:

I wanted something very small, I have a 15 inches Macbook Pro and the thing is very unwieldy for a laptop. I found I didn’t play around or code more because I was lazy to carry that laptop around, I wanted something so small that laziness wouldn’t be an excuse.
I wanted something with a decent keyboard to be able to type fast and code on. Again, I didn’t want comfort to get in the way of coding or writing.
I wanted to run some flavor of Unix in it. Linux or FreeBSD.
Have a text-mode ONLY Unix installation. (This was not at goal at first, but now it is ;)

Yes, text-mode only. No stinky windowing system. No fancy browsers. No fancy terminal apps. Yes, I wanted to man-up and go back to good ol’ text-mode, armed with bash and emacs and the whole stack of compilers, interpreters at their core.

That actually got interesting when I was trying to test how this post was going to look like while typing it in emacs.

Now, with the netbook at hand, I tried FreeBSD and several flavors of Linux before settling with Arch Linux, again for some very specific reasons:

I don’t like installing hundreds of packages as part of the initial installation or having to install Xorg and a huge desktop. (I am looking at you Ubuntu!)
The wireless network card driver worked out of the box with the minimal installation. I didn’t have to do any kind of messing around or having to connect using the ethernet card at all. Huge win.
Its philosophy is exactly what I like, lightweight, minimal. That is, it installs only the needed packages to have a minimal working linux installation, of course, you may install more, but you don’t have to, also, it’s based on a rolling-release system, which allows for constant, small updates, I don’t like using old software.

I just say I love it, I got particularly inspired while reading Rebel Code: Linux And The Open Source Revolution by Glyn Moody, very interesting book.

The City By The Bay

2011-10-29T00:00:00-07:00

The City By The Bay

29 Oct 2011

Just a few days ago, an H-1B Visa application has been filled to the USCIS on my behalf. That means that if everything goes well, I will be moving with my wife to San Francisco, the city by the bay.

This is a pretty exciting move. I cannot wait for it to happen although there is quite a bit more of paperwork to get done before that. I’ve read everything I could find about the city, in books, blogs, etc. We’ve been in vacation there too. I’ve found that people have very polarized opinions about San Fran. Some people are deeply in love with it, some people really hate it.

I find that amazing. If a place can arise so heated emotions it’s a place definitely worth checking out.

I am particularly excited for several reasons, for one, it’s in Silicon Valley, a place where technology is something you can talk, see, discuss, and practically eat. A dream come true for a guy like me.
The climate is a nice addition, I live in a place that can get as hot as 119.3F (48.5C) degrees and as low as 24.8F (-4C) going to a place where the average climate is around 59F (15C) is a welcomed change.

There are other several things that I look forward to: the culture, the access to a lot of different food, beers, wine, music, people, mindsets, flora, fauna, beaches, sports, meeting new people, building new stuff, learning new things, driving new cars, getting new habits, living in an apartment with a view, a very long etc., moving to a new country is a breaking change, a very exciting one.

This is possible thanks to my current employer, INgrooves, which as soon as they learned about my strong desire to move to San Francisco, in the interest of my happiness and my wife’s, they made possible the move. Something I will always be very thankful for.

Installing a Ruby development environment in MacOS X

2011-06-02T00:00:00-07:00

Installing a Ruby development environment in MacOS X

2 Jun 2011

The goal of this post is to show how I do set up my Ruby development environment under MacOS X (10.6.7 at the time of this writing), I am writing it down so I do not forget and because probably someone else could benefit from it. Also, keep in mind that this can probably work on other *nix flavors out there (like linux) without much change.

I originally used Macports to install ruby, but in the end this will cause pain when trying to use different versions of Ruby and their respective gemsets.

OK, the culprit of the problem is having different versions of Ruby to work with, for several reasons this is something you probably want, for example, RoR versions previous to 2.3 run only on Ruby 1.8.*, but RoR 3.* runs only on Ruby 1.9.*, there may be other reasons, but this is why I got into this dilemma.

First of all, you may want to get rid of the version of ruby you installed by any package system you may be using, in my case Macports so I have to do :

sudo port uninstall ruby

After that, we are back to system’s old ruby (1.8.7 patch 174 in my system), what we want to do now is install the Ruby Version Manager, rvm is a nice piece of software that manages the chore of having multiple versions of ruby. Quoting from their website: “RVM is a command line tool which allows us to easily install, manage and work with multiple ruby environments from interpreters to sets of gems.”

To install rvm for development (local to your user account, if you want to install it system-wide go check their website) you have to run the following commands on your favorite terminal application. You have to have git installed for it to work :

bash < <(curl -s https://rvm.beginrescueend.com/install/rvm)

echo '[[ -s "$HOME/.rvm/scripts/rvm" ]] && . "$HOME/.rvm/scripts/rvm" # Load RVM function' >> ~/.profile

source .profile

type rvm | head -1

Please note that .profile is my particular bash configuration script, yours may be .bash_profile or .bashrc, etc., so check that out first.

If after that last command you get a line saying that rvm is a function, you are all set, if you had any troubles then you will have a lot of fun solving them :-)
Anyway, if you had success you now have a working installation of rvm in your user account, so what we want to do next is install ruby! Let’s do that installing 1.9.2 initially, run the following:

rvm install 1.9.2

ruby --version

rvm use 1.9.2 --default

ruby --version

This will install ruby-1.9.2 and use it as a default instead of the system wide, now you can start installing your favorite gems and start coding away:

gem install rails
gem install jekyll
gem install jeweler
...

Now you can install also another version of ruby and switch between them like this :

rvm install 1.8.7

rvm use 1.8.7

ruby --version

gem list

If you do not use the —default switch when running rvm use then the change is local to that session, it will revert to whatever you set as default. If you see, your gem list is empty because you have not installed gems to that version. That’s beautiful. There are ways to manage different sets of gems for the same version of ruby with rvm but I haven’t used this feature yet so I have nothing to say about it.

In the end, if you want to get rid of everything you just have to run

rvm implode

and it will erase rvm, all the versions of ruby you installed with it, their source code, etc., you may need to do some other cleanup, like deleting .rvmrc and removing the line you added to your .profile, but both of these are harmless if you do not do anything about them.

So that’s it. Have fun.

They are just tools

2011-05-25T00:00:00-07:00

They are just tools

25 May 2011

This post was originally written by me for a former employer’s company blog, I reproduced here with some minor edits with permission from them.

Get a bunch of techies together and you can easily start a war of words over any technology. Each will claim his favorite technology as “the best.” But it is all pointless because they’re just tools.

I see from time to time heated battles between techies about technologies, methodologies, applications, etc. Some of the classics are: Windows vs Linux, Firefox vs IE, C# vs Java, Agile vs Some other, Eclipse vs Netbeans, etc. These discussions can be seen in blog posts, books, informal talks, etc. You just have to gather a bunch of tech geeks around and they will start a discussion about how that particular technology they happen to love is better than the rest. It reminds me of a George Bernard Shaw quote:

Patriotism is the conviction that your country is superior to all others because you were born in it.

George Bernard Shaw

We as developers, managers, testers, architects, etc., in the software development industry, must try to see the things from a broader perspective. We have to stay objective and pragmatic. Operating systems, programming languages, software development methodologies, development environments, platforms, etc., they are tools, just tools. There is no such thing as “The best %s”, substitute %s with operating system, methodology, programming language, etc., there is no panacea. If it existed, it would be clear for everyone and we all would be using it without any kind of complain, it doesn’t matter if many people uses it, it is not the best. Because there are no such things.

There’s a catch in this, just like anything can’t be the best, everything CAN be the best too. But, in particular situations, every tool fits a purpose, it excels on some regard, but it can’t excel on everything. There are times when a tool will be very useful and fit in what you are doing, then other times when that same tool will cause you a headache because it’s simply not meant to be wielded the way you want it to. We should approach a tool with care, analyze its advantages and disadvantages and determine if it fits our purposes. Not pick something just because we like it, because it is the only thing we have used before, or because people say it is the best.

As professionals, we should try to read about tools and try to learn about and from them, try them out, etc., expanding our tool set, because after all, we are professionals, we cannot say to a client, or a partner, or our teachers, or our bosses that we cannot get something done because we just know or like one tool. We have to expand our tool set so we can propose and develop many solutions, many ways to accomplish a particular task, and then solve it in the most effective way. Remember, when you only know how to use a hammer, every problem starts looking like a nail.

I invite you to append the phrase “in this particular situation.” every time you are going to say “This tool is the best”.

My setup

2011-05-13T00:00:00-07:00

My setup

13 May 2011

I’ve been reading a lot of usesthis.com lately, I find it very interesting reading about the computing setup, hardware and software, used by other people. The people interviewed by this site are more or less famous people in several professions like entrepreneurs, coders, designers, photographers, etc. In the spirit of this website, I write this post about the setup I use.

I currently use a 15" Macbook Pro with a 2.2GHz quad core Intel Core i7, 8GB of ram, and a 750GB SATA hard drive, I didn’t go for an SSD right now because I need copious amounts of hard disk space.

I run OS X Snow Leopard with MacPorts, Mail.app for my personal mail, Things for my to-do list needs (although I am flirting with the idea of switching to Org Mode), iTerm 2 as a Terminal.app replacement. For communications I use Skype, Adium, and Twitter for Mac.

For programming I use GNU Emacs as text editor and IDE, I keep my customization on GitHub, I use git for source code management.

I use VMWare Fusion to run Windows 7, Visual Studio 2008 using its Emacs Keyboard Scheme, and SQL Server 2008 R2, I use this virtual machine to perform my development work for INgrooves.

I use several utilities like Alfred, I like being able to open apps quickly without using the mouse (I remove every app from the Dock), RightZoom to maximize applications to use the whole desktop, TinyGrab to take and share screenshots, Caffeine which allows me to keep my Mac awake when I leave it idle for a while, Dropbox is a must have for file sharing and syncing.

I also have an iPhone 3GS which I use a lot for email and twitter and an iPad I use for reading ebooks from Amazon, I actually wish I had chosen a Kindle.

Edit – I’ve recently came across two very useful applications that have joined my list, iStats Menu, I use it to replace my time and battery menu icons and monitor my cpu/memory usage, gfxCardStatus a very handy utility to monitor the usage of video cards in 15" and 17" Macbook Pro models.

Francisco Soto - ebobby.org

Scratching your own needs and open source

Scratching your own needs and open source

Structure and Interpretation of Computer Programs

Structure and Interpretation of Computer Programs

Exercises:

Chapter 1

Chapter 2

Lisping and the word ladder puzzle

Lisping and the word ladder puzzle

Word ladder Puzzle

Solving it

Closing remarks

I shall learn Lisp

I shall learn Lisp

Moved to San Francisco

Moved to San Francisco

All text Linux

All text Linux

The City By The Bay

The City By The Bay

Installing a Ruby development environment in MacOS X

Installing a Ruby development environment in MacOS X

They are just tools

They are just tools

Patriotism is the conviction that your country is superior to all others because you were born in it. George Bernard Shaw

My setup

My setup

Patriotism is the conviction that your country is superior to all others because you were born in it.

George Bernard Shaw