I’m a pretty hardcore Spotify user. I haven’t bought a track since I started subscribing to Spotify and I listen to it pretty much 24/7. (Though Rdio has got me curious lately; I’ll make a final decision on that later). I completely embrace the social aspect of the service, even though I’m quite proud of my original Spotify username, before the switch to Facebook logins (hey, they aren’t that common in the US!).

Unfortunately, Spotify does not include a visualizer and even so I quite like the visualizer included with iTunes (even though I use iTunes for nothing else). So I decided I needed to find a way to use the iTunes Visualizer with my Spotify music.

My first instinct was to write some code. I pulled together a ruby script using rake, thin, and a CoreAudio gem, all combined with Soundflower (an audio routing application for Mac OS X). After an hour of failed attempts I came to the conclusion that I was trying too hard. iTunes can already play HTTP streams, so all I needed was a program that could stream the audio from a particular audio device over HTTP.

Enter Nicecast. It costs $60 so I’ll probably looking for some free alternative for the masses (or writing my own once I get around to it) but it works for the time being. It has more features than I require and I’d love something integrated more tightly with Spotify (ex. Sending new song names to iTunes to display them) so maybe I will create a small server application to do it, but for now Nicecast suffices.

So what I did was essentially:

1. Install Soundflower and configure the 2 channel device (“Soundflower 2ch”) to use the Built-in Output. This will take whatever Spotify is playing and make it available to another application through the audio device input “Soundflower 2ch”.
2. Install Nicecast and configure it to stream the input device “Soundflower 2ch” over HTTP. The default port it uses is 8000.
3. Once Soundflower and Nicecast are both running and configured, open iTunes and go to Advanced -> Open Stream… (Command + U). In the box that pops up, type the string “http://localhost:8000″. This will tell iTunes to open an HTTP audio stream that is coming from your computer over port 8000, which is where Nicecast wil be streaming your audio.
4. Turn the volume down all the way in iTunes (or Spotify, either or. Doing so in iTunes will probably have better synchronization between the visualizer and audio but I haven’t tested this).
5. In iTunes, click View -> Show Visualizer (Command + T).
6. You should know see the standard iTunes Visualizer, only it will be be using whatever is playing in Spotify as its source.

I like to have the Visualizer open while I’m cleaning on Sundays as it provides something to look at but isn’t distracting enough to keep me from getting shit done (like TV is). Usually I would just play muted random music I still had in iTunes while Spotify was open, but I like this solution much better.

Thanks!

So this app I’ve been working on has been fun. Since the concept behind gathering and using the data is so simple, it’s given me a lot of time to play with design.

It’s changed pretty drastically since the first screenshots I put up, and now it looks like this:

I’m digging it so far. Definitely not done and needs lots of tweaking, but I think it’s came a long way since my first few designs.

I updated the interface with some tweaks. I wouldn’t say it’s done yet and as this is an experiment in design it probably won’t ever be finished but I generally like the way it looks. Unfortunately there are a bunch of animations a static screenshot cannot show, so you’ll have to build it yourself to get the full effect! (the source is on GitHub)

Yesterday I came to a conclusion. I needed to write some Objective-C code before I went absolutely crazy. C# has poisoned my eyes and I needed something fun, something enjoyable.

I also don’t get to release much code or apps because our client work doesn’t get put on the App Store and my employer doesn’t believe in Open Source, so I figured it’d be fun to put some code out there.

I just bought myself a new iPad 3 so I figured it was worth starting an iPad project. I’ve spent a lot of time lately reading the GitHub Jobs listing, because I like to know what companies are looking for to keep my game up. GitHub Jobs has a very easily consumed API for interacting with their listings, so I decided to work on an iPad application for viewing  those listings. They don’t provide an iPad version of their iPhone GitHub Jobs app, so I’d have to view it in that ugly 2x mode, or use their website. I thought this was more fun then either.

So I broke out Paper, my new favorite app. I have an iPad stylus so I sketched up a few example layouts and then brought them up on my MacBook Pro. I pumped out a quick background image in Photoshop then moved over to Interface Builder and figured out sizing and layout information there, then deleted the layout and recreated it in code using the properties I figured out in IB.

The end result is now hosted on GitHub and I’ll continue updating as time allows (and it’s fun so probably often).

If this accomplishes anything, it serves to remind me just how much I love programming, especially on iOS. The three and a half hours I had to work on that last night was the most enjoyable programming I’ve done in weeks.

Hopefully there is more to come.

Working happily is not always easy.

Programming has always been a passion. My dopamine and serotonin levels increase at the blank return of gcc with the -Wpedantic and -Wall flags set. A clever use of lambda expressions can bring tears of joy to my eyes.

Unfortunately, I haven’t seen much of that lately. I’ve seen a lot of Unity3D. A lot of C#. A lot of Excel sheets. I’ve swapped assets out of a lot of programs.

I think I’m depressed.

I’ve never been this tired in my entire life.

One day I’ll get back to writing iOS apps. Hopefully soon. Or maybe I’ll start writing RoR applications fulltime. CoffeeScript is nice.

I need something.

I hate them.

And yet I have to wear them everyday.

I wish I could be like my cartoon counterpart.

I’ve spent the last month or so writing a decent amount of code in Ruby. Most of it was throw away code that I was playing around with, but I have put a few things up on GitHub that are written in Ruby, namely Spotty and GrowingUp. I’ve also been using it as my preferred language for one-off scripts at work and I plan to use it to build a Sinatra application to power the API for an upcoming project.

My programming background starts with developing homebrew (not the Mac OS X package manager) in Lua, C, and C++. It was an interesting experience, as it wasn’t incredibly easy to be babied into programming that way. The original guys who put together the tools were smart cookies, but they were also of the Unix hacker type. Their preferred development environment was the Unix terminal and IDEs were not very common in the PSP homebrew development world. As I progressed as a programmer and moved away from homebrew development I was introduced to tons of new tools that really helped to streamline the programming process. I left the days of using GNU Make behind and started to use IDEs like Visual Studio and Xcode, depending on the platform I was working on.

Using an IDE also introduced me to other incredibly useful tools like profilers and debuggers that have saved me countless hours over the years. However, I started using those tools almost five years ago, and I’ve been programming for about seven years, so I’ve spent the majority of my time developing with tools that drastically improved my efficiency.

Then I entered the Ruby world. Things are way weird in the Ruby world, mostly in a good way but sometimes not so much. I get the overwhelming feeling that many Rubyists are behind in the world of development. While coding in Ruby is incredibly fun, and I enjoy it more than programming in most other languages, I feel like the standard practices used by Ruby developers are almost archaic. And more concerning is that most of them seem to be perfectly okay with it! It’s almost like Ruby developers don’t know the precious, life-saving tools available to other languages exist. That makes me said.

Let me explain further.

Environment

I first realized something was off when I began researching the best environment for Ruby development. Through lots of googling and scouring answers to similar questions on sites like StackOverflow, I found that many a Rubyist prefers using TextMate and a terminal. I thought (and still think) that this so incredibly bizarre. I am a terminal junkie; I can dig a command line interface. But when it comes to real development, to real projects with scopes higher than spending a few days on a hack job, I can’t imagine programming without an IDE. My work flow is so IDE-centric that it is hard for me to accept that there are still programmers around that would rather stare at a terminal window than the a nice IDE. Granted, there doesn’t seem to be an IDE that really stands out well enough feature-wise for Ruby, at least not that I’ve found, in order to get people to jump onto this bandwagon. Which simply makes me raise the question, why hasn’t anyone created one yet? Where is the Visual Studio of Ruby?

Debugging

This one really hit me when I attended SpreeConf last month and sat through a presentation about writing fast code in Ruby. The speaker (whose name I cannot remember, unfortunately) presented the use of profilers as something special. Immediately, I wondered everyone in the room had not already been using one. I also wasn’t quite sure why it was being presented as a talking point at a conference. When I saw that he actually had the attention of most of the people in the room, it dawned on me that maybe Rubyists don’t have a lot of exposure to tools that I previously that were standard for all developers.

Maybe I’m spoiled, but I most definitely cannot get any real work done without a debugger. Breakpoints are an incredibly useful tool when working with software that doesn’t seem to be doing what you think it should. I know programmers who think its better and easier to litter their code with print statements in order to find certain functions that are executing and what order their executing in, or even to output the value of all kinds of variables. In all honesty, I find that incredibly naive. Debuggers are like magic that should be embraced, yet I don’t see widespread use in the Ruby world. I’m not sure if this again is due to a lack of available tools, but it seems silly that so many people are developing huge projects without the help of a real, powerful debugger. It truly is hard for me to grasp developing projects without being able to pause execution, inspect variables, view a stack trace at any moment, etc. And not only that, but also have all of those features integrated nicely into my editor.

 Design Patterns

I’ve also come to feel like Rubyists lack knowledge of a lot of fundamental design patterns. I can’t attest to the average level of education of most Rubyists and I’m not bashing on anyone’s degree (considering I don’t hold one myself and I don’t attend a university). It does, however, seem to me like a lot of standard practices and design patterns used in other languages don’t carry over into the Ruby world. This first occurred to me after reading a post by Zach Holman from GitHub about developing their software for deployment on github.com as well as their GitHub Enterprise product. I’ve never met Zach personally, but he seems like an awesome dude and he’s really, really smart (I mean he graduated from Cornell, if I recall correctly. It was actually Carnegie Mellon; I should have fact-checked that before posting. Even better though, I love the folks over at CMU.). It just seemed to be a pretty obvious solution and really just an implementation of the Abstract Factory design pattern, but I guess that would was because I’ve used the pattern before? I don’t know, just seemed strange to me! I also get the impression that a lot of the design patterns that they use come straight out of Rails, which isn’t a bad thing, but makes me think that they learned Ruby through Rails tutorials. I’d love to get some feedback about this!

I could be pretty off, but these are just my impressions after being part of this community for about a month. I’d really love to hear from other Rubyists about their points of view, so feel free to spread this around and leave a comment!

So, as the weeks go by and the progression of my life advances a lot of crazy things happen. I was finally able to get myself a car; here she is:

It’s a 2012 Nissan Altima Coupe, and her name is Sexy III (nicknamed Melinda). She is a great ride, I have to say, it’s only been two weeks but I’ve put just under 2000 miles on her, only about half of which can be attributed to my work commute.

Some of those miles entail driving back and forth to the Jersey Shore. I’ve decided that I want to leave near the beach, so I’ve been checking out apartments in various towns along the coast, namely Bradley Beach. I hope to be out there by mid-March, as my parents are pretty set on selling their house and the hour long commute is getting old anyway. This would also give me space for a legitimate office for my Dad Software operations, which will be nice. It also means I’ll have to invest in some new equipment, but that’s okay; my MacBook Pro is getting fairly outdated.

I’ve also done a lot of work in Ruby lately. With the trends in technology and the majority of startups these days being web-based solutions built on top of frameworks like Ruby on Rails, I figured it was a good direction to take. Luckily, I happen to really enjoy coding in it, as well. It really makes me want to take the initiative to start a product company this year and see how far I can take it.

The company I want to start is a collaborative document editing platform based on Git. In my head, I like to think of it as GitHub for normal people, but I’m not sure how much the guys over at GitHub would appreciate that sentiment (and I <3 them quite a bit) so I don’t think those are necessarily the correct words to describe the service, but I’ll pick a nicer description eventually. The hurdle of this project is being able to find the differences in documents and merge them, which for normal text files like source code is already implemented quite well in Git. Unfortunately, Microsoft’s document format, known as OOXML (Office Open XML) is a tad bit more complicated on that, so I’ve been implementing a library that is capable of finding the differences in XML documents and merging said differences between files. You can find the code on my GitHub page under the project GrowingUp. I see it taking about six months with my current schedule before this idea comes into fruition, but hopefully it gets picked up as it really could be quite the nifty service for students, businesses, etc.

With all of that in mind, I have to say that as of late I’m pretty optimistic. Things have been challenging as of late, but I’ve mostly been able to overcome most of the obstacles in my way the last few months, and for whatever reason I expect that to continue in the coming months. I’m excited to see where I’ll be in a year, considering I could have never predicted where I am now a year ago. A year ago I was an unmotivated high school student scared shitless of everything around him and the changes that were looming. Now I’m a professional and happier than ever. Pretty sweet.

I work about an hour from my house. To get there I typically drive a 2003 VW Passat, or more recently my mother’s old Jeep because my car is in the shop. A few weeks ago I started the process of trying to find a new car. I drive a lot (~100mi/day) so preferably I was looking into purchasing a new car. I drive too much to lease and I wan’t something guaranteed to be reliable. New cars are expensive. I was going to need a loan. And this is when I checked my credit score for the first time.

Credit scores are supposed to be a measurement of your risk and liability when a creditor lends you money. I say ‘supposed’ because that’s not always what it means. Without a credit history, your credit score is actually quite meaningless. And even your credit history is a questionable asset, because its length determines its reliability. And that makes sense, right? The longer history you have of good credit, the better candidate you are for a loan. Of course.

Except, well, for people like me.

This is where the part of the adventure becomes oh so fun. I checked my credit for the first time on freecreditscore.com. Unfortunately, it didn’t seem to work correctly and I was charged $15 anyway before being redirected to freecreditreport.com, a sister site that seemingly presents the exact same information, only they also charged me $15. So roughly $30 later I have my credit score. It was just under 700. For the youngsters (ie. those like me, two months ago), that is average credit, not good and not bad. Surely, it was good enough to buy an average car, right?

Nope. And this is where Credit Bullshit Factor #1 comes in: Some lenders (for example, car loan creditors) calculate different scores based on outside factors that you cannot control, even when the score is retrieved from the same creditor bureau. My freecreditreport.com score was from Experian, as well the credit check from the dealer. Both showed the same active date, and my score from the dealer was 80 points lower. I was relentlessly denied my loan.

I don’t have the luxury of someone who can cosign a loan for me. It was never an option. Which is fun because it makes it literally impossible to get a loan in my position. And here’s  where Credit Bullshit Factor #2 comes in: You can’t get a loan without an established credit history and you can’t build credit history without first establishing credit. An interesting factor in all of this is that in today’s society most people attend a university they can’t afford and therefore build credit without really realizing it. But that happens over the course of an average of four years. I don’t have enough student loans to be build any significant credit. Instead, I have a single credit card. With a low limit, because I got it when I was eighteen. Wonderful.

So the moral of this story is that the credit system that runs our country has got me in a Catch 22 that I can’t quite escape. Which is unfortunate, because I’m perfectly willing to pay thousands of dollars for a car and an obscene amount of money in interest if they would simply give me the chance. I need a car, but in the end it’s their loss. Idiots.

Ever wanted to control Spotify from the command line? No? Stop lying.

Well, regardless, now you can!

Check out this nifty little proggy over at GitHub: https://github.com/jparishy/Spotty