Reblog

Deep Objective-C in 24 mins

Sun, 20 Sep 2009 08:39:00 -0500

Deep Objective-C in 24 mins: Stop! Pull off the car if you’re driving and run home to listen to this episode of the Mobile Orchard podcast (click title) with Mike Ash. I heard the best explanation so far of the difference between methods, messages and selectors in Objective-C plus another great deal of the language quirks. All of that in 24 mins!

Runtime

First the runtime: in a typical C-based language there is no runtime. The runtime is responsible for all the parts of the language that aren’t complete at compile time, such as where to search a class to instantiate an object or what piece of code to invoke on a method invocation.

ISA Pointer

An object instance in memory looks like this: the first 4(8 in a 64 bits world) bytes are the “ISA” pointer, a pointer to the class that instance belongs to. Sometimes when an observer needs to observe attributes of the instance, the ISA pointer points to the observer first and then the real class implementation. Interceptor chain in place.

Methods, messages, selectors

So here’s the difference between methods, messages and selectors. A method is an actual piece of code written somewhere in the program. It contains the concrete code, parameters and a return type. A message is what is packaged up when you call a method: target object, parameters and the method name. A selector is an efficient representation of the method name which is used by the runtime to execute quick searches (it uses an integer based representation of the method name instead of a string). You can still call it a method invocation, but before the block of code actually receive control, there are many things going on like routing that message to the correct responder. Since the place where the method call happens doesn’t contain a direct pointer to the method to execute, message-passing seems more appropriate than method call.

Methods are C functions

A class also contain all the pointers to the methods included in the class. Essentially is just a search process: search for right place to go to execute the next instruction and route the message there. An interesting fact is that all methods at the end are just regular C functions with 2 extra-parameters: the ‘self’ reference and the selector of the method that was invoked (that can be accessed as _cmd).

Message dispatching

When a message is sent to an object instance, the runtime searches a selector to perform the operation. When the selector is not found the runtime delegates the class in three different ways:

resolveInstanceMethod: the runtime first asks the class to add an implementation dynamically. You can reuse a method which has a different name (methodForSelector to retrieve a function pointer). You can also implement the new behavior as a C function (with the 2 additional params) and call class_addMethod to add the new method.
forwardingTargetForSelector: if no behavior was added in the previous step, the runtime asks the class to forward the message to a different object. The class can return another object and the search starts from scratch.
forwardInvocation: if no forward was found in the previous step the runtime will package a complete NSInvocation object ( with message, selector, parameters). The class has the last chance to handle the invocation. Something typical is to send the NSInvocation in the NSUndo storage class, so the user can actually undo the operation in case of unexpected results. The class can modify the selector, the parameters, or even re-send the message to multiple objects at once.

My conclusions

forwardInvocation is similar to method_missing in Ruby but the presence of the other two callbacks creates a more structured approach to the message dispatch lifecycle. The main difference seems to be forwardInvocation returns void, so I can potentially accept the message and do nothing acting like /dev/null for that message invocation. I’m absolutely not sure about this, I’d like some Objective-C expert to enlighten me if this is actually possible. The same thing is not possible in Ruby where at least ‘nil’ is always returned by method_missing.

Update

Mike Ash was so kind to reply my question on his blog. Here’s the response:

“If you do nothing in forwardInvocation: then control will indeed just return to the caller. I don’t know about the return value they will see, though. You may need to explicitly zero out the return value in the NSInvocation before handing it back to them if you don’t want them to receive garbage. Note that you need to have an NSMethodSignature to be able to handle these things, which makes it hard to write an arbitrary message handler. If you’re doing nothing then you can get away with an NSMethodSignature that doesn’t match 100%, but you still need the return type to be correct for the forwarding mechanism to work properly.”

ReactTable as an iPhone App?

Thu, 17 Sep 2009 04:54:00 -0500

ReactTable as an iPhone App?:

The ReactTable (click the title) is a visual touch-enabled synthesizer in the shape of a table and several plastic blocks. The user experience involves all senses: it includes visually displace the blocks on the table, manipulating attributes of the modules with your hands and hear the results as output. I was wondering how such an interface could be ported to the iPhone and its multi-touch capable screen.

You need a sidebar with hiding capabilities from where the modules are dragged on the screen. A few oscillators, filters and effects and sampling capabilities again as blocks. Once the blocks are on the screen they behave similar to the ReactTable. I suppose the graphics must be adapted to the phone capabilities, but lines, colors and sound synthesis is available. My collegues at AgilePartners created something similar with Star6 http://www.agilepartners.com/apps/star6 where also body movement is involved. Where to use something like this? Of course live performances.

PragDave on DSLs

Thu, 17 Sep 2009 04:36:00 -0500

PragDave on DSLs:

In this article PragDave draws a line about when it’s time to stop enhancing and wasting time trying to make a DSL read like english (or another spoken language). Spoken languages are imperfect and redundant and this is their strength. The impedence mismatch is clear: programming languages need predictability and writability instead. Fluent interfaces (as from the definition of Martin Fowler) should not be used as a technique to make a DSL read like english, but a programming language more clean and concise in a specific business context.

I think that tools like RSpec or Cucumber didn’t cross that line yet. True, authors of those tools put effort to create a DSL similar to a spoken language but I think the approach is still very pragmatic in nature. What I disagree with these days is the tendency to believe you always have to use tools like Cucumber (or Fitnesse/JBehave you name it) to create acceptances and scenarios even in the case there is no “business customer” reading and editing them. That’s a mistake in my opinion: as a programmer I don’t need the level of sophistication in readability that Cucumber offers because at the same they increase my programming effort. Again, there is a tradeoff you need to consider when you assume all projects should have a complete suite of acceptances. I’m still not at the point to consider acceptances a “scam” thought :) My rule of thumb at this point is: “if it’s taking too long and is getting way too complicated, it means there is something wrong”. Creation and maintenance of acceptances, unit tests, both TDD or test after, should always be an easy and straightforward task.

Agile 2009 Report

Sat, 29 Aug 2009 23:56:00 -0500

Finally I managed to attend the biggest of the agile conferences around. Unfortunately I missed the first 2 days which means 50% of the conference. For the 2 full days I was there I had the pleasure to attend interesting talks, knowing smart people and get a sense of how agile is doing these days. The organization was almost perfect, excluding the confusing aspect of “stages” as categorization for talks. But that’s a minor problem in my opinion. Please jump right at the bottom if you only care about the conclusions.

The first talk I attended was almost by accident considering the complete lack of time I had to go through the program and decide carefully what to see. So the criteria was: choose a title that sounds like new stuff, at least you’ll learn something different. With that in mind I attended “Stepping Up and Stepping Back: the Leadership tipping point” by Pollyanna Pixton. Project leadership talks are not usually on my radar, but I knew Pollyanna by fame. The talk was centered around the idea that today’s style of leadership should be less intrusive as possible to foster team creativity. This is also the topic of the last book of Pollyanna. The exact opposite is the command-control kind of leadership, the one where is the leader who takes ownership of actions instead of letting the team assume the control. The leader should step back even when they know exactly the solution for a problem and let the team learn from mistakes. Apparently leaders appear to do nothing while instead they prepare the team to take responsibility. Not imposing doesn’t mean not to lead. We even practiced how not to answer questions!

Then it was my turn to speak. I think You Say Tomato I Say Pomodoro talk went great. I worried that speaking for 90 minutes was too long, but when you put practice into the mix, finishing earlier is never an issue. I had around 15 people attending which is not a lot considering the size of the conference. Feedback was great, averaging 4 to 5 stars. Probably people already got their Pomodoro talk the day before and they were not interested in another one. I think my title was misleading in this sense, it sounded more like an introduction and it was not. Also: Neal Ford was talking about emergent design in the other room and that didn’t helped a lot :) I’d like to extend the talk to a 3 hours session in which instead of driving the exercises I give them to the public with my supervision.

I then moved on the other building where the Software Craftsmanship North America was taking place. I attended Ward Cunningham’s talk about “bacteria oriented programming”. Don’t be fooled by the apparent non-sense biology, electronics and programming mix of this “old guy” of the agile community. There is an important take away: never stop to a single discipline, move around, let the side thinking permeate your daily programming. He gave us an example of a “fuzzy” protocol called Bynase, where instead of defining a communication protocol, a continuous stream of impulses is used between computers and sometimes the pulse is accepted and sometimes it’s not. This resembles cellular communication where the cell transmission triggers communication between other cells. You can find more here. The line up of speakers for SCNA was impressive but I decided to go back to Agile 2009. That was an hard decision though!

I needed some rest, but I was just in time to hear the remote pairing experience report by Tim Ottinger and Tim Gifford. I was already following Tim’s effort from his blog while doing a similar experience in parallel with my team. Conclusions are the same: no silver bullet but just a mash-up of tools to use to fail-over when connection isn’t perfect. And it’s never perfect. You also need to think about a specific “remotiquette” and learn what you can and what you can’t do at the phone/screen. Mostly common sense I’d say. I agree with their conclusion that we are still lacking a complete solution for remote working even if features should be clear by now. C’mon vendors!

I then participated to my first Agile Jam Session. I’m talking about a real jazz jam session at the Muzic Masti stage where we self-organized to create the band: yours truly at the piano, Chris McMahon at the bass, Paul Rayner at the guitar and Henrik Kniberg at the drums (he was the pianist but he kindly accepted to let me play). We’ve got several other instruments coming and go and unfortunately I don’t remember the names. I stopped only 2 hours later to move to the DWR party at the Elephant Castle with Paul. We were able to stay only 1 hour because after a while we couldn’t hear each other or anyone else because of the confusion. Anyway, great night.

First talk I attended on Thursday was Styles of TDD: First tests by Naresh Jain and Michael Feathers. This was a practice session on TDD with an exercise based on a billing system application to develop. I abandoned after the first break. I couldn’t understand what the goal of the session was. I had the impression we had to develop test first a few features and then discuss what went good or bad, but I’m not sure. If that was the goal, it was too much basic stuff for me. I expected to learn different styles of TDD (whatever that means, that was my curiosity) but it was just an introductory session with people discussing why you should or shouldn’t test a specific feature.

It was then the time of Metrics in an Agile World by Rob Myers and James Shore. After an interesting start about the meaning of “measure” for common life things like the grade for an egg or what is exactly a “good tomato”, I got lost in the pictures. I think I’m becoming very impatient (which is not always good) so maybe this time I was too quick in judging the talk. But I started feeling frustrated when: I realized the pictures were too invasive and when James Shore asked the audience to organize into groups to brainstorm a few ideas about metrics. It’s true: sometimes the best talk is the one where you don’t receive answers but where the attendees collectively found solutions. But in this case I was looking at pretty pictures on the screen and listening to curiosities about grading eggs and then asked to find a definition for metrics. I was not ready to workshop at the table because I couldn’t understand the goal. As I said, I was too quick. I should have done the exercise and stayed a little more. The critique for the presenter is: pretty pictures are fine until it’s evident that they are just used to catch the attention.

I closed the morning with some bureaucracy at the speaker booth and then lunch. For the afternoon, frustrated by the lack of pragmatism of the previous talks, I selected something very practical and Ruby-ish like Acceptance testing Java Applications with Cucumber, rspec, and Jruby by Dean Wampler and Aslak Hellesøy. I was curious to be taught by Aslak about something I knew like cucumber, but not in all the details. It went pretty well, I learned a few things about cucumber I never used and also how to use in cross-language environments. I also got a chance to go back to my Java days and remembering how to program in Java. Man, that was so quick! All those years are still there. Anyway, I had to left before only because there was a talk I wanted absolutely to see.

The last talk for Thursday was Slow and Brittle: replacing End-to-End testing by Arlo Belshee and James Shore. I went there because I think Arlo is a genius and also because I appreciate James’ writing on his blog. It turned out to be a little different from my expectations, but overall a great session. In this case, the fact that the audience was required to work on a problem was clear since the beginning. That’s ok, no pictures, not even slides. Trust engaged. The problem of end-to-end testing is the problem of maintaining and executing acceptances, integration or any other kind of test where the components involved are loosely connected. We decided to name these end-to-end. Now, execution and maintenance of end2end tests is notoriously such a big pain that many teams decide to remove or to do a light use of them. Given the fact that you can’t sell the customer buggy applications, in which way we can replace end2end testing? There was no definitive answer but a list of common alleviators such as good mocking, just the right amount of exploratory testing and even a language tailored explicitly for end 2 end testing. Arlo’s approach is probably the most interesting: they delete end2end tests when the feature is stable and necessary unit tests are in place. I proposed a Pareto-like solution: let’s instrument the application so that the most common usage paths are recorded. Knowing that those usage paths cover the 80% of the application business value, let’s use end2end to cover them and something else for the rest. I was not able to explain my idea to the table, so we opted for a better use of plugin oriented architectures based on the facade pattern. I enjoyed the conversation and the challenge. Impressive was to see James driving the room full of people and the lighting talks.

This is basically the end of my first Agile conference. But probably the best talk of the entire week went on during the banquet. I had the pleasure to see Jared Spool in action with a talk about the importance of user experience design. A great build-up of anecdotes and facts to sustain the thesis that user interface design is the most important aspect of software development. Totally agree and you have to be good at it. He’s just a great speaker, you have to watch it to understand. Some interesting take away: there must be a vision for the product and everyone in the company should endorse it. Good design cannot always be explained completely: you need to learn from the masters and then reproduce in some sort of unconscious way. And many many more. I think this presentation and probably a few others should be online on www.InfoQ.com any time soon.

I had a great time. Too bad I was not there from the beginning and I was too busy the days before. My planning certainly suffered from my poor conference preparation. I also met wonderful people that is probably the most important part. As I heard from others the last year, attending this conference gives the impression Agile crossed the chasm. My impression is more that Agile stalled right before crossing the chasm. Many know about Agile but they are still early adopters and it looks like there will be no more innovation from now on to increase the interest. The Agile 2003 program, for example, isn’t very different from this year program except for the quantity of sessions: after 6 years TDD should be considered as a complete obsolete topic, but we are still here struggling with it.

Not Reinventing The Wheel?

Tue, 11 Aug 2009 05:06:30 -0500

http://www.flickr.com/photos/vrogy/

It depends.

Have you ever been asked to not “reinvent the wheel” by a customer or maybe your boss to implement some functionality for an existing project? It’s a pretty common situation I think. Extension by reuse is a nice thing to have and all well crafted projects with low technical debt are ready to be improved without the need of “reinventing”. But what exactly the boss is asking to the team? The boss is probably just afraid of the team writing the same code twice, without copy pasting (!). If you’re lucky maybe your boss is smart enough to imply “writing the same code twice instead of reusing already existing components”. Anyway, the final goal for the boss is to reduce developing time as much as possible without you wasting time re-thinking something that is already built in the application.

The problem is that to know if you can reuse effectively, you need to know the code-base. If the methods are 100 lines long with high cyclomatic complexity values, chances are that they are very tied to specific use cases and the business logic is scattered across the sources without the necessary modularization. Let’s say you agree to work on this project by just re-using the existing classes and hoping everything will be smooth and easy. The reality is that to avoid to reinvent that wheel you’re now forced to add even more conditionals, follow convoluted paths and potentially breaking other use cases (especially for low test coverages).

What happened? The new feature could potentially take twice as necessary to pay for those wheels that were not reinvented. Second: the wheels are now more tangled than before and exponentially more complicated. The solution is not of course to re-write the code (even though you might be forced to if the situation is desperate) but to apply the legacy code workflow (cover with tests, extract logic, refactor). If your boss fails to understand that the price to not reinvent the wheel is way higher than extending well crafted software, then the project is doomed. This seems often the case for startups with the need to monetize as fast as possible and sell the mess right after. By the way, why do you think your car repair shop wants to call you back to give you an estimate about the damage of you car before moving forward?

Let’s say you explain the danger of accumulating technical debt to your boss. You shouldn’t be tempted to consider copy-pasting a faster alternative to deal with the mess. Reuse by copy-pasting is possibly more exponentially dangerous than spreading conditionals across the code. It’s just a matter of days that you’ll find your self fixing the previous use case forgetting about the copy-pasted-changed added functionality. Seriously bad idea.

Conclusions

So the next time you’re asked to not reinvent the wheel, instead of blindingly accept on the spot because you totally agree, you have to know what the current state of the code is and only after that you can give an informed answer and a meaningful estimate.

Embedding MacRuby

Tue, 04 Aug 2009 07:58:00 -0500

The actual implementation of MacRuby contains a facility method used by HotCocoa macrake tasks and by the embed MacRuby target in XCode. The method only change the executable to point to the embedded MacRuby in the .app file. But all bundles in MacRuby contain a reference to the system MacRuby installed in /Library/Framework, not the embedded version. This prevents the distribution of a MacRuby application to computers without a system-wide MacRuby install.

Waiting for the next MacRuby release where this problem should be fixed, an easy fix is to run install_name_tool on all the bundles in the directory. From the command line:

    1 mkdir ~/tmp
    2 cd tmp
    3 hotcocoa embedded
    4 cd embedded
    5 macrake deploy
    6 LIB=MacRuby.framework/Versions/Current/usr/lib/libmacruby.dylib
    7 
    8 find Embedded.app/Contents -name "*.bundle" \
    9 -exec install_name_tool -change /Library/Frameworks/$LIB \
   10 @executable_path/../Frameworks/$LIB {} \;
   11

Sorry for the poor line wrapping to make it readable. You can check the results with:

The first lines are needed just to setup a HotCocoa example project. On line 8 I’m applying install_name_tool to all bundles in the distribution. The same can be done to a MacRuby XCode project created with an Embedded target.

If your project is HotCocoa based, you can add the following macrake task to the Rakefile in the root directory:

As you can see I’m also removing unnecessary files for a MacRuby 0.4 distribution to shrink the application size down to around 15Mb. Not too bad considering an entire Ruby runtime (MacRuby) is included.

Life Lesson From CouchDB

Fri, 31 Jul 2009 11:59:48 -0500

Another Friday! Time to dump the selection of links that yours truly collected on the interweb in the past weeks. I had to wait a bit to accumulate enough material worth publishing. As usual the description is a mix of quotes and personal opinions about people, things and facts. I also try to elect a “most interesting of the week” and this time I had an hard work. I was struck by the life lesson coming from the development of CouchDB. I didn’t know anything about Damien Katz and this presentation by InfoQ is one of those you see once or twice a year. Damien was laid off, he had to move to a cheaper place and start all over with two growing kids. How do you find the motivation to grow your own idea and live on savings while nobody cares about you and your work is the main topic of the talk. This is how CouchDB got started. Damien also talks about choosing Erlang and JSON over HTTP and some more technical aspects. Simple and regenerating talk.

Newspeak and Pluggable Types with Gilad Bracha - Software Engineering Radio… Here’s the best analogy so far comparing static type system VS dynamically typed system. In a static type system applies something similar to the “presumption of guilt” from the Napoleonic Law: the compiler stops the program (guilty) if the program doesn’t comply to the type system even if it makes perfectly sense at runtime. The compiler can’t prove the program is “innocent”, so it has to be wrong! In dynamically type systems the program is allowed to run and judged only after the facts. Statically typed languages are therefore more restrictive but this doesn’t imply they are more “secure”. Second: the type system is similar to a BDUF (big design upfront) and restricts the possible uses of the language to what it was designed for: have you tried AOP in Java and then in Ruby? Dynamic languages accommodate “side” uses more easily. The rest of the podcast is centered around the features of NewsSpeak, an interesting language that deserves attention.

InfoQ: Jazzers and Programmers… This is mostly about jazz than programming. But I appreciated the concise history of my favorite music with examples, quotes from great musicians and a little theory. I’d certainly point someone to this presentation to have a quick introduction to Jazz. There is a clear parallel between Jazz and programming. Something common is the need for continuous practice in both. We call this “software craftsmanship” and apparently developers of our times don’t practice often enough. I also think that there is less room for improvisation in programming than Jazz. Most of the time in programming you have to follow rigid rules (like classical music) and the real improvisation is when a tool or technology is used in a different and unexpected context, like for example Erlang for mutli-core CPUs.

How Productive Was the LetMeGo Immersion? « Alexander’s Blog – The Making of LetMeGo… From one side I can only admire what a small team was able to accomplish. From the other I can’t stop thinking that this project is seriously screwed. Just the fact that you’re forced to a 90 days 24/7 with something like 12 hours working day to produce a partial beta smells bad. I understand how this can be a wonderful experience. But I suspect they accumulated an huge pile of technical debt. If I were an investor I wouldn’t invest in LetMeGo because it seems like a bomb ready to explode right after a few months of exercise. I could be wrong of course, or just envy because when you have a family you’re done with this kind of things. All the best to the project, we’ll see.

Hanselminutes Podcast 171 - The Return of Uncle Bob… This time Uncle Bob talks about professionalism. IT industry is amateurish to some extents and lacks the same level of professionalism of other professions. Rituals can be a measure of professionalism, since they are the result of a consolidated discipline. Of course you try not to abuse rituals and loose the intent behind the discipline (like completely skip design to jump right into testing, see Jim Coplien). After talking about the need for architects to also be developers to feel the pain they are asking for, Uncle Bob also speaks about the density of a language, intended as the concentration of meaning for a single word or even a single character. See the nice Game of Life in APL screencast that illustrates the concept here: http://www.youtube.com/watch?v=a9xAKttWgP4. I especially like this quote from Uncle Bob: “I want them to find me with my nose stuck between the keys of the keyboard”. Yeah, code code code.

Hanselminutes Podcast 169 - The Art of Unit Testing with Roy Osherove… An interesting podcast again from Hanselminutes. And again about unit testing. Here’s some take away: if you have tear-downs in your tests those are probably integration tests. If you have class based setup tear-down again those are probably integration tests. If you do a lot of corner cases testing around a method, you’re probably doing after-the-fact testing. A good definition of mock object: if you’re setting expectations on an object which is not part of the project, that object is a mock. You don’t make assertion against a stub for example. When do you stop testing? When you’re comfortable with it, that is, when all the ideas about how the software should behave have been implemented. And of course you should stop at the most interesting cases without over-specifying.

Push Notification & Store Kit - An Interview With Urban Airship… Here’s an interesting discussion that explains the technical details of two new capabilities of the iphone sdk 3. Push notification is a stay resident application running on the iphone capable of receiving messages and dispatch them to other applications. There is a server side notification service involved with persistent queues maintained by Apple. The Push Notification removes the need for an app to poll a server remotely dragging the batteries out using a persistent IP connection. The store kit is an API that allows iphone apps to present mini-stores to their users to buy additional capabilities. Interestingly enough, there are companies like Urban Airship producing intermediate layers (or a server with an application on top of it) because the whole process requires good programming and administration skills. Kudos to Dan Grisby for the very good questions.

The Short Term Cycle of Productivity

Tue, 28 Jul 2009 10:58:00 -0500

I’m sure I’m not saying anything new that psychology doesn’t explain already. Anyway you may find some answers here.

The Short Term Cycle

When exposed continuously to the same subject (idea, abstraction, project, whatever), even for a few hours a day, the brain creates a short term memory of the content of that subject. The frequency determines the freshness of the content and consequently our capability to create higher abstractions and side thinking on that subject. I suppose you realized at least once that after a long period of intense concentration on a problem it’s now harder to get distracted at the point of having trouble to sleep. I call this short term cycle of thinking, where an idea can be analyzed and exploited easily with negligible effort.

Productivity

Productivity happens when the short term cycle is established and the brain is ready to build knowledge on the subject with ease. Needless to say, the key to be productive is to maintain the short term cycle alive by establishing a daily (or a cyclic) refresh. At productivity peak the refresh can as short as 1 hour/day (depending on the kind of project of course). For software developers an example of daily refresh can be fixing a bug on a project. 1 hour to fix a bug is enough to keep the project alive in the brain without a tangible effort to context switch. For a piano player half an hour of scales are enough. For a runner, 3 miles 3-4 times a week. Of course it depends on your goals. In general, the popular “daily practice” is what creates the virtuoso cycle.

Feedback

Motivation depends on feedback. More specifically good feedback. When the results of some intense work is positive and rewarding motivation increases. When results are absent or bad, motivation decreases. The feedback can be as “stupid” as a number that goes up or down, a changing color, or some modifications of the physical world that can be seen and measurable. But what’s good or bad isn’t always the important factor. Motivation stays up when accepting a challenge for a partial failure. So the important thing is to find a feedback no matter what or how. The more visible and clear the feedback is, the more the motivation is affected.

Distractions

Unexpected, continuous and random distractions destroy the short term cycle. Good and planned distraction are healthy and welcome. The reason is easy: if the distraction is planned and cyclic it just creates the perfect spot for a managed break of the brain. Do you remember what happens when you move to a new apartment? Several unexpected things can happen: the DSL doesn’t work, the fan makes too much noise, there are all the boxes to unpack and so on. This is random distraction that brings the short term cycle to its knees. Focusing on goals becomes difficult, feedbacks are too often negative, motivation goes down if you don’t pay attention. This can result in a vicious cycle, exactly the opposite of the virtuoso cycle of productivity.

Frustration

The problem is that is not always possible to identify when the distraction pattern is about to change to become random and unplanned. When that happens it usually generates frustration, a condition where the problem cannot be fixed and there is apparently no solution for some long period time. It’s also easy to blame some unfortunate “bad shape” when frustration occurs because the cause of the problem is not known. Of course there is a real “bad shape” but if you are an healthy person with just a few colds a year, is pretty much possible that your frustration is not generated by physical conditions.

Self-check

If you feel frustrated ask yourself the following questions:

Is the short term cycle holding? Are you dedicating consistent and repeatable time to your goals?
Are feedbacks in place? What “numbers” change by working on the goal?
Do you find yourself wandering around for a reason you don’t recall? Like I went to the bathroom then I met a colleague, then I went for a coffee, then I don’t remember?
Do you see a change in the pattern of distractions? Several unexpected interruptions several times a day for a few days for example.
Are there objective reasons to think that you have some kind of sickness determined by external causes? This is usually something a doctor can confirm.

Based on the answer you can understand if what you are experiencing is a fracture of the short term cycle determined by external unexpected distractions that you didn’t recognize as such.

Taliban Mode

There is no easy solution here. The only solution is temporary deprivation. You need to accept to remove several useful habits and pleasures. Temporarily! For how long it depends but usually weeks. The deprivation is necessary to re-establish the short term cycle and consists of removing useless and useful distractions for a while. Total immersion so to speak. Feedbacks in place are a must. How to find or create feedbacks is a subject for another post. I found mine with the Pomodoro Technique. Taliban Mode is how I call the fundamentalist approach to re-establish the virtuoso short term cycle. When it is back, restrictions can be gradually relaxed. Below an example of a taliban mode:

Uploaded with plasq’s Skitch!

What is on the Taliban Mode is very personal. At the beginning it can be more restrictive, for example by limiting (not removing) hobbies and extra-work activities such as sport. The key is to remember that this is just temporary and the result of the effort will be visible only after a few days and more importantly, this is the key to re-establish the short term cycle of productivity. Hope you found this article useful. Let me know how in the comments if you want.

Back From The Diet

Fri, 24 Jul 2009 03:05:00 -0500

It’s about 2 months I started my information diet. I followed the plan without big troubles until now. Now it’s time to understand what worked and what didn’t. Once again the key is balance and contextualization.

The Good

Cutting the long tail: the diet had the interesting side effect of cutting the long tail of information. The long segment of the tail includes very specific and localized news: the more specific the information the less subscribers following that source. The diet moved the “interestingness trigger” higher in the curve by eliminating too detailed source of information. Only the fittest news will survive the long tail and move up (the fit function here is the general consensus that the news requires attention). Since there is a not-negligible traveling time for the news to move up, with the diet I’m trading freshness of information for quality by being not informed as soon as the information is created.
Push vs Pull: the diet eliminates all sources of “push” type of information. If something is sent to you and collected inside an inbox that’s what I call “push”. It can be counter-intuitive: you might think that if there is a subscription then the model is “pull”. True, but the inversion happens when I start polling the subscription to see if there are new items transforming the good push into the evil pull. The bad of course is if you check constantly.
Presence amplification: I don’t remember where I read it, but for each email sent a few more will be sent back to you. It’s not different for other kind of web presences: Twitter, Facebook and a whole bunch of other services offer you the possibility to say something. Don’t get me wrong, that’s great, but when too many feedbacks accumulate you need to allocate time to digest the list.

The Bad

Missing relevant news: of course this is the main reason to stay in the loop. Aggregators like InfoQ (and many others) are at the top of the long tail of information and produce more digested information (for example by summarizing interesting posts from mailing lists) than Twitter for example. But I still missed some relevant information (to me) that didn’t make it to the general aggregator. Expected: this is the trade-off I was talking about.
In the loop: another important aspect of micro-blogging is the way it reports about other people doing stuff. Staying in the loop boosts motivation because it re-creates a working environment where other people are doing what you’re doing. Twitter is much more powerful in this context than blogs or x-casts. This is especially true if you work alone from home without a physical team.
More time available? If you remember one of the reason I started the diet was to spend more time reading books. I thought the time not spent reading online could easily be replaced by books. It only partially happened. I need at least the time to read a chapter at once because for smaller fragments I easily get lost trying to remember what that sentence was about. So yes, more time available but in very short segments not suitable for reading a book. For this specific problem I prefer to allocate a couple of hours here and there.

So I enjoyed in the last two months the possibility to make a comparison between too much and fragmented information and no information at all, or close to that. Trevor was right! :) I need to reduce information consumption or stay away for a while when I’m wasting too much energy. In the last 2 months I learned how to trim information to the essential and how to live without it. Now I can gradually increase the flow back and enjoy staying in the loop. This is especially true these days working alone on projects: the presence of a virtual office with virtual colleagues helps me stay in focus and solve problems. Let’s see.

Programming Languages

Fri, 26 Jun 2009 12:27:17 -0500

This time I want to dedicate the opening of the last 2 weeks’ highlights to programming languages in general. Why? Because I had a chance to attend the Chicago Chapter of the ACM presentation with Ola Bini on Ioke. Programming languages are a business domain exactly like banking or insurance with the difference that the “business analysts” is a programmer by definition. For some reason I didn’t pay too much attention in the past to this business domain and I was wrong. Shame on me. I came to the conclusion that learning about compilers, optimizations, expressivity, AST, interpretation and so on is vital to the life of a programmer. Of course you don’t need to be able to create your own language, but you should know what we are talking about. Back to the presentation: I think Ola was giving his best. Of course Ioke is Ola’s little kid, who wouldn’t be thrilled to talk about it? Sure enough the talk is about the language, but there are interesting cross-language considerations. I realized how specific is the domain of languages, it really requires you to be into it to understand everything. For this reason, Ioke is a good teaching language because it’s all about language theory than for example, performances or concurrency. Final note: stating that all other languages are crap is not fair, even from the point of view of expressiveness which is subjective matter. If expressiveness of a language is the deviation from the idea you have in mind and what actually can be coded, then also Ioke is crap to someone who of doesn’t think the same as Ola.

Everyman Report

Thu, 18 Jun 2009 14:24:00 -0500

For the past two weeks I tried one of the polyphasic schedules called Everyman. I enjoyed the experiment, especially the first 10 days but I had gave up at the end. Here’s how things went.

I first did a preparation period where I tried to consistently stay up late at night but without constraining the core sleep to 3 hours, i.e. without waking up at 5am.
I then moved to the following schedule: core (2am-5am), nap-1 (10am), nap-2 (4pm), nap-3 (9pm)
I initially decided to compensate for the decreased sleeping time adding deep relaxation 5 minutes micro-naps between pomodoros. I thought that throwing this into the mix was a good integration strategy.
Micro-naps turned out to be a bad move. You don’t want to interfere with the 20’ naps where you want to enter REM as soon as possible. In other words, you have to feel really tired to achieve that kind of intense sleep and micro-napping was preventing this.
The adaptation phase end was on day 6: I fell asleep immediately and dream vividly during the nap while before I was mostly awake. The day before I was not able to follow the schedule and that I think triggered the sleep compression during the 20’ nap the next day.
On the second week I started having problems waking up after the core sleep. Yes I was awake but unable to anything than mechanical things until 7-8am. I started questioning the benefits after 3 mornings in that condition.
I decided to add an additional nap to the mix changing the schedule to: core (2am-5am), nap-1 (10am), nap-2 (2pm), nap-3 (8pm), nap-4 (10pm) but the problem after the core was still there and I also experienced sleepiness after 1 hour from the 20’ nap

The last move didn’t help and maybe worsened the situation. I browsed the polyphasic forum in search for help to see if I was doing something wrong. It turns out that is not enough to just follow the schedule and pretend that everything is ok. The next step after the adaptation is to search for the optimal core positioning during the night and the other naps during the day so that they are more consistent with the new body sleep requests. Since it was already demanding for me the fact to follow a sleep schedule, I finally gave up.

Wow, what an experience! I enjoyed having a couple of 8-days weeks and the boost of productivity especially at the beginning. But the initial boost went back to normal for the above problems at the end of the second week. So I had to make a decision: if I’m not going to use those additional 4 hours a day for things that I like to do because I’m too sleepy to do them well, what’s the point? If I have to spend time reading forums and experimenting on tweaking the schedule, what’s the point? I will definitely give polyphasic a second try as soon as my life allows me again to experiment a little more, but for now I have to concentrate on other things.

The strategy that worked really well for me until now that I’m going to resume is to have relatively short nights of around 6 hours sleep and micro-napping between pomodoros.

Pomodori 0.3

Tue, 16 Jun 2009 07:28:24 -0500

I’m happy to announce Pomodori release 0.3. Just follow the link and the installation instructions on the page. For those who don’t know, Pomodori is the pomodoro management application I’m using every day since February. “819 pomodoros and counting!” is what I see right now. Pomodori isn’t just a timer, it’s a tool implementing the Pomodoro Technique. At this point Pomodori is missing several important features and that’s the reason to call it a zero something release.

Pomodori improved my day by day implementation of the PT featuring essential aspects without my assistance: start a 25’ countdown, ring, ask me for a description, give me a 5’ break, ring again, start another pomodoro. Recently Pomodori can also answer questions like “what did I learned yesterday?” or “how many pomodoros can I plan for today?” and so on. Clearly this is just scratching the surface of the technique. For example, right now the inventory and the day by day todo list are external plain text files that one day I want to see integrated in the tool.

Technically Pomodori isn’t just built for time to market, quite the opposite actually. The project is my playground for MacRuby, something the typical user of the PT sure cares about! The fact that it’s targeting only the Mac is also a barrier for mass adoption. So dear customer, be patient if you don’t see the standard behavior expected from a mac app right away, I’m learning all about Cocoa right now.

In this release, 0.3, you can finally access partions of the Pomodori database. This is limited to yesterday’s and today’s pomodoros but the plan is to extend the search to any ranges so you’re free to dig deep into the past. Announce: with 0.4 you should see an exciting new feature coming up, which is just the beginning of the social part of Pomodori.

Developers! If you like Ruby and the Mac please join me on github you won’t be disappointed. Pomodori implements an interesting MVC architecture and it’s fully built TDD from the ground up, view logic included, no XCode required. Especially if you know Cocoa/Objective-C, that’s my weakest point. Enjoy!

Intentional and DSLs

Sat, 13 Jun 2009 05:59:00 -0500

In what now seems to be a biweekly installment, I’ve read and listen around quite a bit lately. Since the beginning of my information diet, I have way less processing to do and my sources are only a couple of conference videos online and a few other things. The item that generated the biggest train of thoughts was the release of the Intentional software workbench that I heard of while reading Martin’sMF Bliki. DSL workbenches are a fascinating topic these days and there is sure potential in our industry. The typical use case for DSLs is medium to high complexity business logic that usually is described by business analysts in a non-executable formats. The workbench can be used to maintain the sync between the generated DSL and the business view of rules. Why not using user stories like the rest of the application? Because the business logic is so complicated that it requires a detailed description and verbal communication is not enough. With a DSL workbench duplication between the Word documents and the actual code is eliminated by using an abstract language that describes the domain. Just be careful: the presentation talks generically about “creating software” without specifying that we are talking about the DSL portion of it. Don’t use these products to generate the whole application!

Other notables include in no specific order:

Compass: A Real Stylesheet Framework… Here’s a very nicely done screencast on how to jump start quickly on a web page design based on sass, blueprint and compass. Chris is kind enough to explain basic concepts, when to use id or classes, sass basics, how to organize your project and so on. The power of mix-ins in sass is great and makes thing quick and easy. As Chris says at some point, you can write your self most of these stuff, but why? Sass generation is unobtrusive and sass template are very readable. The grid system is a breeze once you understand how to attach the column width information to divs. All pretty easy stuff. Thanks for the great screencast.

RailsConf 09 DHH Rails 3… I think it’s the second time I heard about custom attributes in HTML 5. Rails 3 is going to use custom attributes to signaling the framework how to build the javascript actions connected to events, like onclick(). Remains to understand when the transition will actually happen for legacy browsers. Another interesting thing is the rewriting of generators so that scaffolding can be tailored for the particular choice of javascript library, ORM mapping strategy and so on. Rails is still opinionated with defaults but it should be easier to coexist with different opinions.

Industry Misinterpretations 138: Who Killed What… Interesting response here to Uncle Bob “who killed SmallTalk” keynote. If you skip the discussion about the definition of “dead” which is useless in my opinion, I like the “renaissance” model in which a powerful language which is no more fashionable at some point, becomes mainstream again for some unexpected conjunction of facts. At least this is the hope of the SmallTalk community. I don’t know if that could happen though, considering that SmallTalk evokes old technologies that didn’t work (being that true or not). What maybe is possible is the re-incarnation of SmallTalk with a different name, exactly like old good marketing rules tell us all the time.

Scotland on Rails 2009 - The Ruby Object Model - Dave Thomas… This is basically the screencast no.1 from the pragcasts made up as a presentation. I viewed that again with pleasure because Dave is a great speaker and the topic is always hot. Ruby is strictly object based as it should be for an OO language. The strange thing is that passing the time the pure OO heritage has been lost starting from C++, Java and the rest that came after. In those languages a Class is not an object but only something that the compiler knows what to do about it. In Ruby class are just “simulated” as interaction between objects that contain methods and a pointer to the “parent”. This is the reason of the great flexibility of Ruby, everything is an object model and can be accessed anytime.

Episode 136: Past Present and Future of MDA with David Frankel | Software Engineering Radio… MDA is presented in this podcast as the evolution of UML which with after the introduction of OCL was trying to be more specific and semantic. Sorry, I just don’t get it and what I hear is pure fluff. As far as I can understand, MDA is trying to be a visual language for languages. Components can be specified using MDA and the code generated accordingly. In the opinion of David Frankel abstractions are emerging from different industries and similar tools are created to model the application. From what I can remember, this was going on for decades, but we never had the power of building the big unifying abstraction to describe all business components. And by the way, what is wrong in choosing a language and evolve reusable components and stick with it for, say, 5 years? Then I throw everything away and switch to the next language, so what? I understand using DSLs to describe portions of an application, but I don’t understand why I should create the whole application as a DSL or MDA.

Hanselminutes Podcast 163 - Software Metrics with Patrick Smacchia… Interesting talk on metrics here. It’s always good to remember the there are good and simple metrics that cover most of the cases without the need of an exotic mathematic formula. For example lines of code by feature can reveal unwanted complexity for comparable features. Another interesting one is loc covered by test ratio. Loc is not enough to guarantee quality of code. Cyclomatic complexity can be used to spot difficult-to-maintain code. While too high afferent (incoming) coupling (Ac) means probable SRP violation and it’s time to extract one/many interfaces to create dependency on abstractions. There are also composed metrics: CRAP is one or the maintainability index. But these are numbers without dimensions and it’s is easy to expose false positives because of their complexity. A new one I learned here is the MethodRank, the rank algorithm applied to the method dependencies tree. At the top there are methods which should be tested more carefully because of their high dependency.

Pomodoro-GTD Interview

Wed, 03 Jun 2009 18:28:00 -0500

I had the pleasure to attend the recording of the last episode of the Virtual GTD Study Group. The topic was “Perspective and Control”, a matrix chart that describes different states of focus but I’ve got a chance to introduce the technique and give also some advices for beginners. I talked about how the Pomodoro Technique helps staying in the “Captain & Commander” quadrant and other more general discussions. I also had the opportunity to explain why in my opinion the Pomodoro Technique and GTD integrates so well together. Overall I enjoyed the questions and the discussion and I had a very pleasant time. For the impatient, the Pomodoro chatting starts around 32:00 but don’t miss the previous part that explains what Perspective and Control is and how to use it. Also, consider to subscribe the podcast if you are interested in GTD and self productivity in general. Tara and the other guys are very supportive and you don’t want to miss their help!

Pomodoro VS GTD

Sat, 30 May 2009 12:35:53 -0500

Here’s my reading notes for the last two weeks. I definitely had a lot of thinking on how to integrate GTD with the Pomodoro technique and that’s my main topic this time.

Productive Talk Compilation: 8-episode podcast with GTD’s David Allen | 43 Folders… I’ve listened to this series back in time and I was curious to re-listen this conversation between Merlin Mann and David Allen about GTD to compare with the Pomodoro Technique. There are definitely lot of similarities. Basic principles are the same: avoid procrastination, focus on what is important and ultimately getting things done. But I see clear differences also: GTD focuses more on the collection phase while the Pomodoro Technique is more about execution and tracking. Thus the two technique mix together very nicely. Pomodoro doesn’t say anything about how to empty your brain out or give a name on what is in your head or the organization into folders and context. On the other end GTD doesn’t talk about prioritization processes or tracking to collect metrics. Also in the PT interruption handling is much more specific and reviews are daily. Last: GTD does way a better job at marketing the technique than pomodoros. That will change in the future, I think.

Lifehacker - David Allen’s Making It All Work a New Look at GTD - David Allen… Interesting chart here. On the axis, perspective and control. The 4 resulting quadrants are very typical situations for everyone of us. High perspective means knowing at a glance everything that we want to have done and knowing that nothing is outside that list. Control means that we decide the priority of execution and how to manage that list. Low perspective, low control, means poor slave. High perspective high control means “captain & commander” of you life. You go crazy when even if you maintain your high perspective you don’t follow your plans. I’m 80-90% in commander state but sometimes I fail and go “crazy” state. The main reason for that remaining 10-20% achievement is lack of sustainable pace because it happens almost only when I’m tired.

GPGPU - General Programming GPU… There’s a lot of interest in what GPU can do other than processing vertexes these days. It is pretty much the case that your actual computer is already equipped with a > 200 cores underutilized GPU (unless you play a lot of 3D games). NVidia and ATI already produces SDK to exploit this computing power other than games for highly parallel stream processing. So instead of off-loading high load computations to some external form of parallel processing you can think of just run them on the GPU with surprising results. GPUs are much more powerful than normal multi-core CPUs for parallel processing so it make sense to use them instead of conventional parallel architectures.

Hanselminutes - BBS era… I’m really enjoying IT history lately and here’s another interesting piece of the story. I was too young at the time of BBSs to remember, too bad. BBS are similar to our IM of nowadays but as said in the podcast there are big differences. At the beginning, the computer of the SYSOP had to be completely dedicated to maintain the connection and the SYSOP could see user actions, like painting screens and drawing text. As such it allowed a complete control over the communication channel, with the option of jumping right into the user screen to ask questions or offer for help. It remembers me of the difference between modern cars, all electronics and pre-assembled pieces and old cars that could be potentially torn apart with a screwdriver to be inspected easily.

Joe Hewitt - Mobile Orchard… Joe Hewitt, author of Firebug, moved to iPhone development lately with one of the most downloaded app from the AppStore, Facebook. Several core components from the Facebook app have been extracted and cleaned-up to become an open source collection of components called Three20. In this podcast Joe talks about the development details in Three20, html table cells without UIWebview, a Quartz based rich text editor for text field, an auto-resizeable text field and the popular photo chooser. I enjoyed the very technical conversation even if I’m not proficient with iPhone development. I immediately linked the Three20 project hoping to play with it soon. A good listening.

Going Information Diet

Fri, 29 May 2009 10:13:48 -0500

I’ve got the idea not a long time ago. Main reasons behind the decision are:

I have a long queue of books I bought waiting to be read and I can’t find the time to read them.
I want to test the theory about consuming well digested and consistent information (such as books or essays) over partial and half-baked ideas (Twitter and also the majority of blog entries, plus mailing lists)
I feel the need to consolidate many years of open loops in my profession, scratching the surface of a topic and quickly jump away to ride the wave of the next cool thing.

To be clear: I want to test in practice the assumption that partial information is also partially useful. I think there is a not negligible effort to filter out the garbage and often the ‘cool thing’ of the moment is not directly applicable to solve the issue at hand without heavy manual intervention and related context switch. I understand that this is the way you do research on new ideas and contribute back with your support. But this is just a diet and it’s supposed to end after a while :)

I don’t feel overwhelmed by current feeds, email, tweets or reading queues, especially after the recent pruning I did. But still, I can’t ignore that list of books waiting for me and the need to remove those distracting jumps I often experience from half-baked information. I also know I’m going to remove some very valuable source if I don’t follow blogs and tweets. That’s too bad, but I want to be proven wrong first.

The recipe:

Twitter: I’ll just stop following and updating. I removed my twitter iPhone app. I’d like to update, but If I do I know I’m tempted to see replies. Direct messages are ok.
Facebook: only personal stuff, pictures, keep in touch with old friends, no work related.
Feeds: uninstalled NetNewsWire. I won’t read feeds anymore.
Mailing lists: set up filter to move messages and mark as read. Unsubscribing is too long to do and by the way, what if I change my mind? :)
Podcasts: I’ll keep them because I only listen while running. Plus, it’s digested information most of the time.
Current reading queue/video: I’ll just save to read later some blog entries because related to my projects.
Google: of course! Whatever is related to the task I’m doing found on Google is good to read, blogs and tweets included. But the dependency is inverted. I just don’t want to search the net for generic ‘news’.
Mail and IM: no changes here.

As for my weekly highlights section: it won’t be updated often as before, but since I keep reading and listening around I’m pretty sure I’ll keep posting. For sure I have my thoughts on the book I’m reading. I’ll be happy to hear your reaction on this. Ah, the good old blog comments…

Ruby VS Smalltalk

Fri, 15 May 2009 21:14:25 -0500

A little better on my reading queue for this week’s highlights. I think the most interesting post (of course from my absolutely opinionated view) was the Uncle Bob’s keynote talk at this RailsConf 2009. I always enjoy to hear interesting pieces of computing history and Uncle Bob is clearly a skilled storyteller. It must be fun (and also sad when you realize how old you are :) to write talks adding pieces of your personal history. What killed Smalltalk? It was too easy to make a mess. But also: image without source files, not free, competing implementations. Also a wrong attitude: Smalltalkers thought their language and tools were so good that they don’t need to be compliant with the typical corporate IT infrastructure. The presentation is a concentrate of great thoughts. What is clean code? Is code that reveals what it does by reading it. If the WTF/min is != 0 is not clean. Ruby risks the same because it’s powerful. What can we do? Craftsmanship. Leave the campfire cleaner than you found it. A collective effort to maintain the code clean should save also the most powerful and risky language. Good start tdd: has infiltrated the ruby culture much more than it did with smalltalk.

Kent Beck - To Test or Not to Test? That’s a Good Question.… I also don’t test for specific cases. When I don’t it’s because I’m missing the skills to test effectively, that is, in an easy and consolidated way. Let’s take Rails view specs with rspec. I know how to spec them out very quickly, mocks, render directives and so on. Almost a no brainer. But there are other cases where it takes me a long time to figure out how to mock certain APIs, what methods should I call and how to organize the spec suite. So my rule became: if it’s taking too long or it’s too complicated fork a new task to spike and learn about it. But now ship it! It’s brutal I know but usually that’s the correct thing to do. Of course the meaning of “too long” is strictly project dependent. Then I put shame on me because I was missing a “tool” in my tool set so that next time I can’t be taken by surprise. I know I need practice.

Introduction to Wolfram|Alpha by Stephen Wolfram… This is the screencast that introduced me to the work of Stephen Wolfram. Wolfram Alpha is an incredible piece of software, capable of correlations and interpretation beyond what I’ve seen so far. I’m wondering what kind of semantic engine is behind the web interface. This engine is capable of attaching meaning to the human knowledge and serve it at the speed of light. Google killer app? Nah, I don’t think so. What you see on Wolfram Alpha is opinionated, a mash-up of related information that the engine thinks you may like. Wonderful if you want to infer knowledge from data you don’t know about, less useful if you know what you’re searching for. That’s what Google is about when you input some words in the search box. Will it change the way we use the web? Again, I’m skeptic.

Cellular automaton - Wikipedia, the free encyclopedia… Looking at the WolframAlpha phenomenon I ended up wandering wikipedia reading about cellular automaton. I’m amazed by how complicated a model with simple rules can be. Very simple CAs like the monodimensional rule-110 are even turing complete. I also realized that the Langton’s ant and Conway’s Game of Life are to popular implementation of CAs. Some of these models are often seen in nature (predators, chaotic systems, population models etc.) and therefore is tempting to think that a basic combination of simple rules is responsible for biological life. What are those rules is the subject of Wolfram’s book “A New Kind Of Science” which is already in my Amazon basket.

Episode 134: Release It with Michael Nygard… Sad: the book is standing on my bookshelf and I never managed to read it. Good: this episode remembers me what I’m missing. First: my knowledge of production systems just scratch the surface. For some reason in my career I always move when the system starts its life and that’s not good. The podcast follows the book structure which is a nice to read patterns collection. Here’s some interesting bite of the conversation. A system that self-adjusts or shuts down a specific feature when a functionality doesn’t behave as from the SLA is better than timeout. Timeout usually creates more dangers. Ajax completion on key strokes is of low value and high server impact. I don’t agree with this one, it depends on the application if this is low value. Caching can be good, but too much caching or caching done wrong can be dangerous. SLA inversion anti-patter: forgetting that SLA of dependent systems are correlated to the SLA of the main system. And much more. Recommended listening.

Story Mapping

Sun, 10 May 2009 21:53:53 -0500

Again not so much time this week to look around into the web-sphere. My reading queue is growing, the video one is worse. Not to mention podcasts, since I couldn’t run this week for a severe back pain. I decided to report on the few things I was able to collect a summary about.

The most interesting of the week

I realized I was using this organizational pattern for user stories already. The new user story backlog is a map collect stories, epics and tasks on a permanent board. Instead of having only the current iteration (or sprint) board, all stories are organized permanently on another huge board where relationships and context can be maintained. I’ve seen this in practice working as a consultant for a project managed by ThoughtWorkers. As the article clearly stated this is nothing new but just a pattern emerging from multiple places. After I heard about minimum marketable features from naked planning this is the time of “minimum viable product”. They mirror the same thing. Epic is another synonym. The important point in this approach is that stories belonging to different epics are worked together to release a product which is “epic-complete” but maybe not story-complete. Stories are prioritized, epics really aren’t.

This Week’s Highlights

Podcast #50 - Blog - Stack Overflow - Steve Yegge… It sounds like at Google are creating an standardized support layer which adds language specific features to IDEs. If you take for example IntelliJ and Eclipse they provide the same quality Java support features like autocompletion, inline help or compile as you write kind of stuff. The same happens for other IDEs and languages: they are implementing the same functionalities over and over again. As a developer for example I’d like to have autocompletion in TextMate but that’s not enough for me to move to Aptana. My understanding is that they started from JavaScript support to create the framework, supporting their internal type system for the most important IDEs. Of course they have to support also other languages to go public with the framework. Maybe one day we’ll be able to command+space in vi and have autocompletion :)

Stefano’s Linotype - On Twitter… Mmmh. Stefano thinks that when information is just so not-digested is difficult to understand the ROI of the effort required to follow. It’s like reading reddit, infoq, tuaw etc. every day. All wonderful sources of information but those news are so “new” that they can turn completely useless in just minutes. It’s like gambling: in this case the risk is to waste time. He talks about Twitter specifically. But for me Twitter is not the place for news. What I’m mostly interested in is what are other people habits, what they do during the day, how they can so productive, what extra-job activities they have and when. For me it’s a source of completely new information, nothing to do with IRC or blogs where personal habits are completely out of scope. Before Twitter I couldn’t really know what software geniuses were up to or in which way they tackle a problem during their everyday life at work. Twitter is for me inspiring 90% of the time. No gambling.

Industry Misinterpretations 133: Smalltalk and FPGAs… Enjoyed some history of the Squeak community. Squeak users somehow self-organized to avoid a community split when squeakers with different ideas wanted to create their on branch. Sad fact: SmallTalk was too young to be used in the early eighties when memory consumption was an issue and people were choosing C++ for that. SmallTalk is now considered too old without having spent a period as a mainstream language. It looks like there is a lot of interested about hardware implementation of languages for specific business on FPGA and GPU. The first reason is of course the always decreasing price of such a devices. In this podcast an FPGA implementing smalltalk instructions is only running as a simulation but soon to be “printed” in hardware. There is a one-to-ten ratio for a transistor implemented as FPGA over the actual number of transistors actually used. Still a good ratio considering ad-hoc hardware design on one side and generic CPU like Intel’s on the other.

SmallTalk in SmallPlaces

Fri, 01 May 2009 21:05:55 -0500

I had less time to read/listen/watch in the last two weeks. So I skipped the summary of the most interesting reading for the last week. Ok, let’s talk about SmallTalk then. I’m very disappointed I never found the time to learn about what can be considered the father of all the modern languages you hear about. Unfortunately I need to keep this desire low priority in my task list for some more. Even if I’m not actively following, I noticed that the SmallTalk community is alive and kicking, producing software, podcasts and tons of screencasts. Anyway, Industry Misinterpretations 129: Smalltalk in Small Places is about running Squeak on the iPhone. The process is a bit complicated: you need to strip useless classes from the VM and compile all down to C and use an Objective-C to SmallTalk bridge to connect the two world. The micro-VM was used to run Pier (CMS) which runs on top of SeaSide. So you’ve got pretty much all the SmallTalk possible goodness on the iPhone. The interview is a fascinating trip inside the internals of the VM, the garbage collector and the Obj-C to SmallTalk bridge. Have a peek at http://isqueak.org.

Lessons In iPhone Game Marketing… This is an interesting and sad listening. It talks about how important it is to get in those top 100 by iTunes store ranking for whatever good/bad application. The sad part is that 6 months of development for a game can bring to 500$ in revenue if you miss that top 100. It means it has nothing to do with quality, robustness, reliability of software, but with good marketing. The top 100 is reached after a certain number of downloads after the launch or because Apple decides to feature the app. The integration of the number of downloads over the time doesn’t matter even if you have a great average/day. The way you can get into the top 100 are pre-releases to send to online specialized websites for review, advertisement with promos, a light and free version that seduces the user to buy the 5$ version. In one word “buzz” that needs to converge at launch time to reach the tipping point. Just want to remember that in the AppStore quality is not as important as good marketing.

O’Reilly Open Source Conference - Robert “r0ml” Lefkowitz on Open Source… Here’s a funny and short presentation. Robert Lefkowitz is a skilled orator in the ancient roman sense. And is right from the Quintilian’s Institutes of Oratory one century B.C. that apparently our modern “phases” of software development come from. It’s hilarious how such an old essay is applicable to our modern times and the similarities between the Microsoft development process or RUP. From there Lefkowitz explains his idea for an Open Source development process: exceptional driven development. No requirements, no nothing, just straight deploy waiting for customers who create tickets to request what they need! Of course this is a parody but there is some truth, for example in the description of what a requirement is. A requirement is the expression of our fear, an illusion of power to domesticate the future of the soon to be developed software. Naked planning comes to mind: eliminate the waste required to produce almost useless estimates.

Chariot Tech Cast - Grails… I was curious to see how Grails was doing after a couple of years away from the Java world. Good to see that now Grails is a solid framework that can be used exactly like Rails. Type Grails app-name from the command line and you’ve got your nice project layout to start with, no hassles. I was thinking that if I need to work on a Java web application again I will definitely start from a Grails app, write tests and pure Java at first (a language I know) to gradually transform and move to pure Groovy. Sounds like a plan.

Why you have to engage in social media, even if you don’t want to… Summary: a web presence is not sufficient to guarantee popularity anymore. This was the case 10 years ago but today for each line of business there are tons of competing companies all with good services and products. Solution: social networks. Web presence today means 2 things: contents (the old blog) and social networking which works like a review system by word of mouth. I work for a software house and I think the same thing applies here. There are tons of good programming firm and the only way you have to enter the “cool kids” status is by word of mouth by social networking. First step: put decent contents (not just for marketing) on the web, produce open source software, speak at conferences and user groups. Second: build trust by publishing opinions and pointers to your content via social networks. If you don’t do this your customer base risks to become stale.

The Web 2.0 Show - Jason Fried… I enjoyed this interview with Jason Fried which is very actual despite the date of recording, January 2006. I never read “Getting Real” but I suppose what I heard here is more or less what’s on the book. Speaking of which, “Less is More” is one of the 37Signals slogans which refers to everything: less developers, less pages, less features, with the goal of creating something simple but complete in each part. I’m sure you can do everything interface first, but I prefer the approach of front-end back-end at the same time and in the same team. Interesting the approach of asking the customer feedback after the application is rolled-out. Basecamp was created in 10 hours/week for 3.5 months: it takes that long to create a great product if you stay really focused. The perpetual beta of some products is just bullshit because it looks more a way to apologize in advance for the crappiness of the product. Better focus on something 100% done from the start instead.

The Web 2.0 Show - Eric Meyer… Here’s an old (2006) interview with Eric Mayer. Eric talks about the future of paper-based publishing especially in the computer science field. Today is more profitable to self-publish your work considering how easy it is to create a following with just your web presence. If book publishing companies want to survive they have to adapt to some form of electronic process, offering authors editing or marketing services disconnected from the physical creation of a book. That’s exactly what happened thinking at the Pragmatic BookShelf or the O’Reilly online book format. There is also some room in the interview to talk about Eric’s experience. He became the CSS guru publishing tons of content about CSS for free and only after he was offered to write the popular book. He talks also about the UI design process, starting from photoshop comps, merging all layers, slicing and starting creating the box layout.

How to take a 5 minutes nap

Fri, 01 May 2009 00:32:00 -0500

Read this… Read this… Read this… Read this… Read this… Read this… Read this… Read this… Read this… Read this… Joking :) Your attention please.

The Pomodoro Technique advocates a 25 minutes of quality, focused work followed by a 5 minutes break. There are so many ways to spend the break time, but the main goal is to recharge the brain and allow for background processing of previously assimilated information. The consequence is that you shouldn’t be tempted to spend the break reading emails, news, making phone calls, or anything that generates additional pressure to the following pomodoro.

So for example looking at the above picture, I can say that looking out the window requires less effort than talking or reading emails. At the extremes there are: “sleeping” and “working”. Focused and quality work is the goal of the pomodoro, a focused and quality relax is the goal of the break. I made the mistake of thinking that just looking at email subjects or news titles was enough relaxing for a break but after comparing it with 5 minutes of deep relax I changed my mind.

Ideally, the goal of the break should be light sleep for 5 minutes. I don’t know if it’s possible to sleep, but for sure you can train yourself to do better. After a couple of weeks of self-inspection during the break and relaxing techniques I can say I’m very happy with the results. I always had bad days and those were drastically reduced by the Pomodoro Technique. But I still have bad days or half-days sometimes. I discovered that a good quality 5 mins break can give me immediately back the energy to start the next pomodoro with unexpected ease.

The problem is now how to quickly fall into deep relax. I had success with the following:

Find a comfy chair or if you happen to have one at work, a couch
As soon as the break starts, close your eyes and find the best relaxing position. You neck, arms and legs should be perfectly relaxed.
Think about a light scanner (!!): a horizontal line of light starting from your head going down to your feet, very slowly. While the line of light touches all your muscles concentrate on that single area and further relax whatever is there. Especially important are the eyes: careful remove tenseness.
Think about a white giant rectangle gently floating around. If that disappears no big deal. It’s just a starter thought to get you distracted from thinking about the goal of the previous pomodoro.
When the break is done, gently open your eyes, start the pomodoro (or have that started automatically because you’re using my tool), focus and go.

You know that you’re doing it correctly if those 5 minutes feel like 10. All the time I failed to properly relax, I payed the consequences after 5/6 pomodoros. Something I also tried was to sleep during the 20 minutes longer breaks. That was real sleep, but never too deep to be counter-productive. Needless to say that also the long break is important as the shorter ones for a good day of pomodoros. The technique works very good in environments with low noise and familiar (where people don’t pay too much attention at you). I borrowed the idea to train the body to deeply sleep in short period of times from the polyphasic sleep model, a fascinating (and scary) way to sleep less.