Sunday, December 9, 2007

Why second life has no impact on my current life and on my immediate future

There is a huge, increasing, rather incomprehensible (at times) push for the creation of virtual universes. Second life is maybe the most successful and talked about manifestation of this phenomena. An entire industry has spawned around the idea of virtual universes, used, not just for fun and pleasure, but for everyday activities and businesses.

While I can see kids and adolescents increasingly participating in such environments to connect to friends and for playing MMOPGs, I have a hard time believing that such alternative universes will have significant impact to businesses in the next five years---other than the Gaming industry.

Why I am skeptical?

Well on the surface these new worlds are exciting and do serve a purpose, but extrapolating that experience to be a surrogate to real life is jumping to conclusions and a mistake in my opinion. My arguments against the rise of metaverses is simply that they:

1) Are too simplistic compared to the complexity of the world. The real word is complex and hard to understand but works really well as a coherent whole. One only needs to read any accessible exposé of modern Physics to see what I mean here. Why would I want to do business or meet friends in a virtual second rate world when the first world is economical and offers so much?

(Photo credit: Brenda P. and self at Lake Tahoe in November, 2005)

2) Suffer from what I call the digital curse - that is all information on these worlds, like almost all digital information, can easily be copied, lacks security, and can be tempered-with with minimal means of non-repudiation. These are symptoms of many business problems in cyberspace, e.g., music and video. Until there is a comprehensive solution that also allows open access, virtual worlds will only be interesting footnotes in the catalog of business assets.

3) Lack the many dimensions of social gathering and human contacts. Like the telephone and TV before it, the internet and now metaverses are simply new mediums for human contacts.  However, just like these other alternative mediums did not replace our need and the satisfaction we find with real human gatherings and contacts, virtual universes are only a temporary and convenient means of satisfying that primordial need.

4) Forget that humans are natural animals. Humans have evolved to love, blend, and sometimes destroy nature. This evolution occurred for millions of years and I believe that it is imprinted in our DNA. It's hard to believe that less than 20 years of cyber-existence will erase millions of years of evolution...

Virtual worlds are a means to an end. They help us imagine, fulfill idiosyncratic fantasies, and gather when otherwise it would be hard or impossible.  In some situations metaverses will flourish but I would venture in predicting a backlash against such environments and a curbing of the current craze, for nothing replaces real human contact and we are far far from an accurate depiction of nature in our digital inventions....

(Photo credit: self during Raleigh December 2002 ice storm)

Sunday, December 2, 2007

ooPSLA 2007 - part 4b

ooPSLA 2007 in Montréal, Canada - Oct. 21 to Oct. 25, 2007 (this is the part 4b (and last) of my braindump on ooPSLA 2007. Please see part 1, part 2, part 3, and part 4a)
Another side effect of attracting so many experts in any one field is that ooPSLA typically ends up having great panels. This should be expected since, almost by definition, one becomes an expert in academic settings (and to some extent in industry as well) when you do good work but also can defend it when placed in unfriendly environments---where colleagues with criticisms or alternative approaches and ideas.

This year was no exception; tons of really cool panels with many well respected experts and famous figures. I attended four panels and want to briefly highlight three: Simula 67, Silver bullet, and SOA.

Simula 67 panel
Forty years ago the language Simula 67 was introduced to help facilitate the modeling of reality and thus allow help with simulations and other computing tasks that try to replicate real life. This led to what Brooks called the most effective advance toward a silver bullet in computer science we have ever known: object-oriented languages and systems.

(Photo credit: self with iPhone.  From left to right, Guy, James, Bertrand, Anders, and Ole)

To celebrate the 40th anniversary of this historical language, Joe Yoder, panel chair at ooPSLA 2007, managed to get in the same room:
  1. Guy Steele Jr. and James Gosling, both of Sun Microsystems, and co-creators of the Java programming language;
  2. Bertrand Meyer of ETH Zurich and creator of the Eiffel language and;
  3. Anders Hejlsberg of Microsoft and main creator of the C# language;
  4. Ole Lehrmann Madsen of Aahus University and co-creator of the Beta programming language.
Like most such 'roads' down memory lane, a lot of it was good old reminiscing time, however, a few poignant moments marked my memory. First, someone commented, to wild applauds, something to the effect that ooPSLA has become too much of a collection of papers adding or analyzing some aspect of the Java programming language and that needed to change. I have attended enough ooPLSA to remember when the program was not mostly about Java extensions and the likes. As a proponent of the virtues of dynamic languages and as a happy polyglot, I could not agree more.

The last thing that stuck to my mind is Ole's recollection of the grander than life Kristen Nygaard (the creator of Simula), who singlehandedly not only co-created the field, and in so doing impacted computer science profoundly, but Ole also reminded us that Kristen was an important figure in his country's politics and helped shape his country's position with regard to the European Union. I could not help but notice that such multifaceted characters are nowadays becoming rarer and rarer.

Silver bullet panel
An interesting, fun, and at time comical panel "celebrating" our resignation that the No Silver Bullet thesis is still very much in effect and that years of efforts have hardly put a significant dent into making good software easier to create. There was a slew of panelists, which made it a bit diluted, but noteworthy attendees were David Parnas of the University of Limerick, Ricardo Lopez of Qualcomm, Martin Fowler of ThoughtWorks, as well as the Silver bullet man himself, Fredrick P. Brooks of the University of North Carolina.

Two memorable moments are worth discussing. First, Brooks gave a short summary of his Silver Bullet arguments and how over the year it has still remained valid as well as how it is sometime misconstrued. Brooks attempted to remind us that his primary argument, though empirically deducted, has a strong mathematical foundation... I am less convinced of the latter, though, now that I have a brand new signed copy (my third) of the book, maybe it deserves some torn-age by a third read of the text.

The other interesting tidbit to mention is really the courage of 
Martin Fowler (ThoughtWorks, Inc).  After an 
interesting metamorphosis that lasted almost a full minute, Martin reemerged as the storied werewolf on Brooks's book cover. What transpired was Martin playing the mythical beast that never seems to die. Parnas mentioned that we are able to hurt the werewolf with lead bullets but nothing significant to make him disappear. It took courage for Martin to do this and keep a straight face (voice) and at time he
 came across with satire of Colberesque quality... However, the act also became boring at the end and at times distracted from the important themes and the overall conversations while also limiting the time of other panelists.
(Photo credit: self with iPhone of Silver bullet panelists.  Notice Martin's werewolf costume on far right)

SOA panel
The final panel I want to mention is the SOA panel which assembled a group of industry representatives such as Kerrie Holley (IBM Fellow), Dave Thomas (Bedarra Research Labs), Brenda Michelson (Elemental Links), Nicolai Josuttis (IT Communications), and John deVadoss (Microsoft).

After the typical short introduction by each panelists, which saw a regurgitation of your typical SAO kool-aid, though this time with a focus on the importance of looking at the business-side of SOA; that is, separating the architectural concepts from implementations (e.g., Web services or WS-*), and the importance of standards. What followed was a series of interesting "friendly jabs" (pointed questions and comments :-) between panelists and audience members. Since I was part of the conspirators, I'll limit my comments simply to say that I will always attend any panel where Dave Thomas is present. While I don't agree with everything he says, Dave's flamboyant character and speak, along with no-BS attitude, generally results in the truth being spoken...

Of the other panelists, Kerrie was maybe the most calm, cool, and collected and he stayed on message. As far as I could recall, Kerrie's message was that SOAs must reflect the business imperatives and be a projection of the business functions of an organization. While I would agree in theory with with this vision, in my opinion this aspect is less important to debate since as in most interesting ideas, the devil is in the details... Since some of the discussion also centered around the ageless REST vs. WS-* and company implementations, the details argument becomes more interesting. For me, this is analogous to saying that a BMW M3 and Ferrari F350 are sports car. At various levels they are, however, the latter is THE sports car by excellence; the differences dear Watson is in the details...

Parting thoughts
Visiting Montréal outside of the winter is always a treat. A wonderful city with kind folks working hard to hold on to their disappearing roots and culture. As a native french speaker, I always enjoyed to visit places where I am addressed in my mother tongue and also get to meet
 many of my countrymen. The Haitian immigrant population in Montréal is substantial and many of my old high-school and neighborhood friends have made the city their home. Got a chance to also visit many young cousins that I had not seen in 15 years or more.
While the conference allowed me to go down various memory lanes, the best parts and may be most memorable moments, were getting to meet, chat, argue, and even friendly fights, over wine and beer, with colleagues from both academia and industry. Just to name a few, and as a recommendation to never miss meeting the following if you are at a conference where they are presenting or are just attending: Eric Mejyer of Microsoft, Gregor Hohpe of Google, Brian Foote of Industrial Logic, Dave Ungar and David Bacon of IBM Research, as well as (who can forget) Dave Thomas of Bederra Research Labs.
(Photo credits: Self with iPhone of David presenting the best student paper award during the McCarthy keynote and of Dave at the hotel lobby)

Thursday, November 29, 2007

ooPSLA 2007 - part 4a

ooPSLA 2007 in Montreal, Canada - Oct. 21 to Oct. 25, 2007
(this is the part 4a of my braindump on ooPSLA 2007. I decided to split part 4 into two parts since I generally like reading blog posts that fit into one screen page of my laptop and imagine a majority of blog readers feel the same. Please see part 1, part 2, and part 3)

In addition to various paper sessions and one big poster session, like most week-long conferences, ooPLSA includes a wide variety of workshops, co-located symposiums, and tutorials. Unlike many other conferences, these secondary sessions are attended and instructed by the leaders in the field and many times by the progenitors of the technologies and ideas.

These other sessions attract industry participants and thus create a good mix of attendees. For instance, this year, while waiting in line to get lunch, I met developers from one of the big US Banks and they swear by ooPSLA and one has attended the past five years. He had managed to 'infect' other colleagues and they are now a group of three attending this year.

Workshops, symposium, and tutorial

DSM/DSL workshop
Since my recent research centers around using the Ruby on Rails platform to create a domain-specific language (DSL) for Web APIs mashups, I had to attend the domain-specific modeling/language workshop at ooPSLA. I did not have a chance to submit a workshop paper so I attended as a regular participant. Overall, the workshop spanned three days, which I think is a bit much; I only attended the first day. The AM session papers were a mixed of incomplete DSL and approaches to create applications using DSL and DSM. After a nice lunch near old Montreal, where I got to have lunch with some of the organizers, we reconvene for the PM sessions which were deeper and also seemed more mature, as there was a variety of demos and more in-depth discussions.

Overall, I thought the majority of the papers dealt with visual DSLs, that is environments that encourage or facilitate application constructions with visual representations of the DSL. While I realize that there is a growing class of users (non-programmer types) who need to create applications and that one can target with such visual DSLs, I also convinced (based on experience) that visual languages are better suited for very narrow problems and do not scale well. My experience using VisualAge C++ (circa 1996) and then VisualAge Java (circa 1997) have left bitter tastes in my mouth when it comes to visual programming environment. I was able to build a complex application that we shipped to our customers, however, because the application was non-trivial, only a handful of developers could modify and debug it. My conclusion at the time was that the visual code can be harder than textual code. I did not see anything from the presentations at the workshop that convinced me that a significant breakthrough was achieved. I would agree that for some subset of problems and users, a visual environment is very productive and attractive, however, I think it's best to layer the visual tools on top of a textual DSL or a platform supporting a textual language, e.g., Ruby, Rails, Python, Java, or C#

LINQ tutorial

The one tutorial I attended this year was by Eric Mejyer of Microsoft on LINQ. First off, I only attended a part of the tutorial, it was scheduled as an all day affair on the first day of the conference and I was at the DSM/DSL session in the AM. I had met Eric the night before at the bar of the hotel and we had various interesting conversations along with other folks (e.g., Martin Fowler) on many topics. I knew Eric was giving the tutorial and told him I would come for at least part of it. The one thing I must mention right from the start is that Eric is a truly cool dude. I rarely can say this of Microsoft colleagues I have met, but Eric is just cool. He's a real asset to MS, not just for his many contributions, but also overall attitude that debunks the MS engineer stereotype, i.e., "the typically arrogant, I know most everything and the world runs on MS platform" types.
(Photo credit: self with iPhone of Eric Mejyer of Microsoft at the Hyatt Montreal hotel lobby)

Microsoft's Language INtegrated Query (LINQ) has been in research in development for a while now. In the recent version of Visual Studio 2008 and the C# 3.0 language, LINQ is now a prominent feature. In a nutshell LINQ adds new syntax, semantics, and libraries to the C# language (and really the .NET framework) to support direct query and manipulation of relational data. In other words, using LINQ in your C# and other .NET enabled languages, you can do simple to very complex queries of relational data or other data structures directly in your code. For instance this is some LINQ C# code to do some simple queries:

//Assume customers is a C# (or .NET) collection of Customers
//this can be in memory populated or loaded from a relational DB
Customers[] female_customers = from c in customers
where == "female"
|| == 'f'
orderby c.age
select c;

//Another example
string[] cities = {"San Jose, CA", "New York, NY",
"San Francisco, CA", "Miami, FL",
"Raleigh, NC", "Portland, OR",
"Seattle, WA"};
string[] cities_in_california = from city in cities
where city.EndsWith("CA")
select city;

(you should easily be able to infer the SQL equivalent, though the EndsWith() and ToLower() selection operators maybe slightly tricky...)

Software Engineering Radio is running a blog episode 72: Erik Meijer on LINQ where he explains the basic. MSDN host a dated but still interesting video of Anders Hejlsberg discussing LINQ and C#.

However, note that unlike in various DB drivers and language wrappers (e.g., JDBC) or even ORMs (e.g., Rails' ActiveRecord) you never deal with SQL and all results and intermediary variables are C# objects and classes. MS added various new additions to C# and .NET framework to make that happen. From my limited understanding of LINQ (based solely on taking half of Eric's class), it appears that under the cover, the LINQ queries are translated into calls to the .NET LINQ libraries which are heavily templated C# classes to represent various generic version of queries. I am guessing that the same magic occurs for regular data structures when you use them in LINQ queries. Under the covers, I am also guessing that the LINQ .NET engine does appropriate "magic" and generate optimized SQL for the database. Naturally, these optimization will depend on what database you have and not simply the DB driver you installed. Therefore, I would venture to guess that on MS SQL this will work well and dandy but your mileage will likely vary if you use other DBs, e.g., MySQL, DB2, or Oracle. Since I am not sure 100% on previous statement, please don't quote me on that.

Generally, I am a firm believer in having a uniform representation of all parts of a software system. That is, reduce the impedance mismatch that occurs as one integrates different parts of a system. For instance, in typical Web applications development, the application logic is in some language and framework (e.g., Java or C#) but the user interface is coded in HTML, CSS, and JavaScript. Same also for the data when in a relational database. The various frameworks have facilities to reduce the impedance mismatch, however, for databases, even the best frameworks (e.g., Ruby on Rails' ActiveRecord) show their weaknesses when you need to do any moderately complex queries (e.g., a query that involves a couple of joins). What typically occurs is that the database binding layer will simply have a pass-thru that allows SQL to be directly submitted. The promise and beauty of LINQ is that the impedance mismatch is almost completely removed since you only deal with the language in question, say C#, and can represent all data elements and queries thereof directly in the language.

This is all good stuff. However, enter some dose of skepticism. I already identified the first problem and that is using MS .NET and LINQ, I wonder how much that ties you to MSQL since for any decently complex DB application you'll start needing the query optimizer and if that is not ported to work with the LINQ engine then forget anything but a complete MS solution.

The second issue I could see is one I had discussed with Eric. He has not convinced me otherwise. It is simply that there is potential for abuse by developers using LINQ. What I mean is that the relational database community has spent a number of years exploring and addressing the limits of the relational model such that it is now well understood and can scale really well. These advancement in great part have enabled the current Web commerce boom we have seen in the past 10 to 15 years. Show me one decently large commerce or Web application and I will point you to an example deployment of relational database. By bypassing SQL with a language that is not a proper subset or equivalently researched you may loose the benefits aforementioned.

Finally, since as far as I know, LINQ is not a standard or submitted to a standard body, though I know that there is an effort to create a Java version named jLINQ, I worry how much longer this will remains a Microsoft-only technology. So I realize that MS invented it but that does not mean it should not be a proposed standard which could allow it to be added to various languages and importantly allow various DB vendor to fully support it in various settings... I am likely dreaming a bit here, however, imagine if IBM and others had not created the SQL standards. What would have come of the database market? What about all the nice advances mentioned earlier?

Dynamic Language Symposium

I attended part of the DLS this year, as I had ooPLSA 2005. It's an interesting bunch since many of the originators of early OO languages are in attendance, e.g., Dave Ungar (visiting researcher at IBM Research), Mark Miller (Google), Jim Hugunin (Microsoft), and many others.

The talks I attended varied from very practical to esoteric. For instance, Jim Hugunin had a very interesting and practical talk on the new .NET dynamic language runtime (DLR) which allows .NET to host (relatively easily) various dynamic languages. Jim was the one to give us JPython (now Jython) so it was reasonable for him to implement Python on the DLR and share some of the results. Cool thing is that Python works and performs well on .NET---without a thorough study, he mentioned it was twice as good as Jython on one Java VM. He also mentioned that there was effort to also move JavaScript and Ruby to the DLR. Interestingly as in any ports, there are subtle issues that come up, especially how to integrate the .NET library and support it in the language. Not sure if MS plans to share some of the DLR spec or ideas with the rest of the world, however, this may be a glimpse into the future... A portable, solid, and performing virtual machine that can host efficiently various dynamic languages. (The JRuby folks are thinking along that line as well, see Headnius blog on the topic). Kudos to Microsoft for advancing this agenda though at the same time it worries me since I doubt this will ever fully work on Linux or the Mac. One esoteric talk was RPython which essentially allowed Python code to be typed... weird though I can see the statically typed heads inflating and smiling.
(Photos credit: self with iPhone of Dave Ungar (creator of Self) of IBM Research and Mark Miller of Google asking questions during keynotes)

Sunday, November 18, 2007

Why I love Ruby? Reason 1: because strings change and when manipulated should stay strings and be readable

Why strings are critical
Many modern languages come built in with string libraries or better with strings as a first class concept. Arguably, languages that have not done so have suffered significantly from that shortage; case in point C++ which, in the early 1990's, saw a variety of string libraries from vendors fighting for dominance, while the language itself became less relevant and surpassed by better alternatives.

The issue may on the surface appear to be unimportant, however, in practice having excellent string support in a language is hugely critical. Most tasks involve some type of string manipulation or usage, e.g., file input and output, strings as keys to hashes, and for user interface, just to name a few. This simply implies that a language that facilitates strings manipulations results in a real productivity boosts for programmers. In the case of Ruby, as I hope to convince you, the string support is so comprehensive and advanced that the common string tasks become a breeze, but also have a nice side effect of keeping the code rather readable.

The Ruby designers have chosen to make strings a first class type and the language includes a comprehensive library supporting strings. Unlike some other languages, strings in Ruby are mutable. This means that strings, when manipulated, do change and do not result in unique copies---Ruby has the concept and basic type of symbols that can be used for that that purpose. This decision has interesting consequences, though let's look into the basic string type usage and implementation in Ruby. The following Ruby code snippets illustrate the usage:

s = "this is a string" # creates a string
s += ', and this is another' # shows that strings are created with double or single quotes

The built-in String class contains tons of methods and also includes various modules (more on that in a future WILR Reason) that provides enumeration, comparison, and partitioning. Some basic methods:

s.capitalize # => "This is a string" as a new string
s.capitalize! # same result but modifies the receiver

s.upcase # => "THIS IS A STRING" (a new string)
s.downcase # => "this is a string" (a new string)

s.split # => ['This', 'is', 'a', 'string'] as an array of the elements
s.split('is a') # => ['This is ', ' string']

s.gsub! 'is ', '' # => "Tha string"

NOTE: s is modified to new value, Ruby idiom to use ! for methods with side effects

Advance manipulations

s.include? 'is' # => true
s.include? 'Is' # => false

s.insert 9, 'nother' # => "This is another string"
s.replace 'string' # => "string" (modifies string s) 20, '_' # => "_______string_______"
s.squeeze # => "_string_"
s.crypt 'password' # => "paHjoO.AYUKRQ" (one-way cryptography)

There are also various methods for matching with regular expressions, e.g., String#match, String#grep, and String#scan . I'll discuss them in a future WILR Reason since regex support is one of the reasons :-)

Perhaps the most interesting and powerful aspect of Ruby strings are their support for having inline statements and the ease in which multiline strings can be defined and created.

a_string = 'cool'
"this is a #{a_string} string".capitalize! # => "This is a cool string"

x, y = 22.0, 7.0
"#{x}/#{y} = #{x/y} is an overestimate approximation for Pi which is closer to #{Math::PI}" # => "22.0/7.0 = 3.14285714285714 is an overestimate approximation for Pi which is closer to 3.14159265358979"

Creating multilines strings is as simple as:

s1 = %{Ruby on Rails
A clean, agile, and powerful Web framework
Created by David H. Hanson at 37signals}

Ruby on Rails
A clean, agile, and powerful Web framework
Created by David H. Hanson at 37signals

s1 == s2 # => false since s1 does not include the last newline
s1 += "\n"
s1 == s2 # => true

Final thoughts
As you can see, Ruby's String support is comprehensive and very easy to learn. The String class comes also built in with enumeration and comparable features. These aspects allow strings to be used like any other enumerable data types (e.g., arrays and lists) and also be compared for sorting and other comparison-based algorithms.

Because strings are mutable implies that the Ruby virtual machine can make efficient allocation for String instances. This is in sharp contrast to the Java programming language, for instance, which mandates immutability of strings and where multiple copies of strings with the same value can eat at the heap space.

Finally, the fact that strings can have embedded statements and creating multiline strings in Ruby is so easy has an interesting side effect when doing metaprogramming. In a nutshell, with some careful usage the metaprograms can be as readable as the code that they are representing. More on this in a later WILR Reason.

Sunday, November 11, 2007

ooPSLA 2007 - part 3

ooPSLA 2007 in Montreal, Canada - Oct. 21 to Oct. 25, 2007
(this is a continuation from my ooPSLA 2007 review part 1 and part 2)

Noteworthy talks
Aside from the keynotes, I attended a few other noteworthy talks. In particular I want to mention three.

Martin Rinard of MIT presented an Ownard! paper entitled Living in the Comfort Zone. This is a continuation of Martin's work on what he calls failure-oblivious computing or Acceptability-Oriented Computing. In a nutshell, Martin is fundamentally questioning our notion of usable software. My interpretation of his main argument follows. Since all software will have bugs, he questions whether we can approach software construction with the explicit assumption that these bugs do and will always exist and whether we can simply make the systems more resistant to inputs that cause problems. In recent studies for various small, but heavily used systems, he experimented and collected data that seems to corroborate his hypothesis that there is a comfort zone in which most inputs to the system could be reduced to and thus have working software that is resilient to bad inputs. He experimented with both the pine UNIX mail reader as well as the commercial AbiWord word processor.

The second talk was by a truly interesting fellow named Brian Foote who, over the years, has also acquired a reputation for asking tough questions at ooPSLA keynotes and talks. Brian's presentation was very unconventional and he was introduced as the 'conscience of ooPLSA'. Having had wine and a chat with Brian two days earlier, I would have to personally agree with the preceding words.

Brian's talk is based on a paper that he wrote with Joe Yoder entitled BIG BALL of MUD. Brian introduced his talk, if I recall correctly, as "An introduction to Post-Modern Programming." It certainly is an out of the ordinary talk by a rather unique speaker. It's a collage of what appears to be a random survey of important thoughts, ideas, people, and failures in modern software engineering. However, there lies what I think is a coherent message and thesis in all of this blurry and witty exposé, and it is that software, perhaps due to its human roots, seems to have a certain inertia toward complexity and convolution. Anyone who has worked on truly successful and decently BIG software systems can attest to this tendency. Things seem to generally get worse, not better. The code becomes a big mess and market and customer pressures always seem to prevent one from ever reengineer for the better. Some techniques may help, such as Test Driven Development or TDD and Refactoring, do help but they are not perfect, they can require considerable efforts, and they can aggravate things in other ways, thus just shifting the complexity elsewhere. Maybe Brian and Martin should meet and marry their ideas. Seems like Brian has identified the problem and Martin is pointing to one, albeit resigned, solution.

The final talk I want to mention is Erich Gamma's (IBM Rational) talk on Jazz. This is the latest initiative from the people and the company that brought you Eclipse---the Rational division of IBM. Jazz is sort of an expanded version of the Eclipse platform containing all sorts of jazzy add-ons for team collaboration. For instance, Erich showed how a distributed team of developers for the Jazz itself platform is setup and how he could join one of the sub-projects. After joining, Erich could list the current TODOs, features, team members, and so on. All bug reports can be assigned to any members of the team who can also collaborate by doing instant chats and sharing white boards and other collaboration tools. Everything is transparent to members of the teams. All events and actions are recorded as RSS/Atom feeds that team members can consume in the comfort of their favorite feed reader. All in all, Jazz promises to make for distributed software development what Eclipse did for individuals... While the demo had a few glitches and the room was crowded to the max, with people seating on the floor, I left feeling good being an IBMer and hopeful that Jazz will allow distributed software teams play together like these bands I hope to see again in New Orleans.

There are still some questions about Jazz's availability and license. I will stay out of it for two reasons. First, I personally don't think that everything that the IBM Eclipse team does should automatically be given away for free, we are a for-profit company, and in this case the OSS business model seems inexistent. Finally, I am not part of the Jazz team nor do I know the details behind the project or their motivations, goals, and customers.

A lot of people raved about the 50 in 50 talk by Dick Gabriel (IBM Research) and Guy Steele Jr. (Sun Microsystems) but I did not see it. I was visiting some old high-school buddies who live in Montréal and that who I had not seen for more than 15 years. So in many ways I had my own reminisce time and was happy to get second hand account of Dick's and Guy's exploit down memory lane.

In what will surely be my final ooPSLA 2007 post (truly this time) I will complete the braindump with a recall of the LINQ tutorial, the DSM/DSL workshop, and the DLS symposium. I'll briefly mention some highlights from the different panels I attended and give a brief carricature of interesting colleagues, friends, and folks I met at ooPLSA this year. Easily my favorite ooPLSA of all previous years.

Change history (marked with strikes and emphasis)
11/25/2007: minor English updates and additions

Wednesday, November 7, 2007

ooPSLA 2007 - part 2

ooPSLA 2007 in Montreal, Canada - Oct. 21 to Oct. 25, 2007
(this is a continuation from my ooPSLA 2007 review part 1)

Embarrassment of the riches

Photo of Fred Books and Bertrand Meyer (inventor of the Eiffel language)

The first thing that one notices from this year's ooPSLA program is that it is chockfull of BIG computer science names, such as, Turing award winners John McCarthy of Stanford and Fred P. Books of University of North Carolina Chapel-Hill (formerly of IBM), as well as David Parnas of University of Limerick, Ireland, Pattie Maes of MIT, and Gregor Kiczales of University of British Columbia (formerly of PARC). With so many famous keynoters, to fit the program in three days, some of the research paper sessions were concurrently scheduled and that created a vacuum at these sessions... Not a huge problem for a well-attended conference but made it difficult for me to attend 'non-famous' sessions.

I managed to see most of the keynotes and only missed Maes's talk---conflicted with yet another invited talk by Brian Foote of Industrial Logic, Inc. (now consulting at Google and other places.) More on Brian's talk in a future post.


Brooks talk was about collaboration and briefly about why the Mythical Man-Month thesis still remains mostly valid today after more than 25 years. I got three main takeaway from his talk: 1) software engineering is hard and still remains intricately a human-intensive process; 2) most important human works typically have one primary designer/architect. Brooks gave examples in all fields, e.g., Michelangelo's Chapel Sixtine, Frank Ghery's Guggenheim museum in Bilboa, Spain (see photo, credit, and many others; the one exception to the solo team structure is the pair, e.g., cited pair programming as a successful agile practice; and 3) Brooks thinks that object-oriented technologies are the closest, so far, to the elusive "silver bullet".

McCarthy's keynote centered around a new programming language called Elephant 2000 that he has been working on for a while. Mostly reminded me, and others, of efforts from the multiagent community on speech-act and agent-based programming. The best part of the talk in my opinion was a series of Intro slides on LISP's history that a member of the audience ask him to go over. It's always cool to reminisce on the beginning events that led to the creation of aspects of computer science. For instance, McCarthy mentions how DARPA provided the first funding in the 60's to create CS at MIT as a gift for the war efforts and how, as they do with all such grant, MIT divided the money to each of the major departments. The Math department got this influx of money and needed to spend it. Minsky and McCarthy were lucky to get some for a crazy idea that they called "artificial intelligence" along with a bunch of math graduate students...

Parnas's talk was mainly about documenting software systems and the difficulties that typically arise. Parnas gives as a current illustration of the problem (which may have ended recently) the long running battle between the EU and Microsoft over allowing competitors to interoperate with MS servers by giving enough documentation on Microsoft's protocols. Apparantly the first effort was in the order of 10K pages and was full of inconsistencies and contradictions... Parnas advocates more mathematical verbiage and precision to help this general issue.

Overall, it was nice to see and (in some cases) meet these famous computer scientists. And their general focus on basic research and fundamental principles (gathered empirically or mathematically) is an important reminder to us all. I personally got a chance to speak to both Brooks and Parnas. So kudos to the ooPSLA organizers for inviting them.

However, I cannot help but also point out that both Brooks's and Parnas's talk focused on topics that seems to be a bit at odd with the ooPLSA mostly agile crowd. Brooks was intensely advocating having an architect and a level of 'blueprint' for the system and this could be seen to be a bit at odd with the fact that in the current world, time to market pressures and constant changes in the marketplace make this approach (to its fullest) mostly unrealistic thus the general idea of not doing big-design up front (aka BDUF) in agile teams.

Parnas's documentation rethoric, while clearly needed for a class of software systems, is likely unrealistic in most real-world settings where there is a shortage of programmers (and well educated engineers) and the fact that having working malleable code will get you your contract signed faster or get you ahead of competitors much quicker than one could finish reading the huge amount of of documentation needed to precisely describe even the simplest of systems. Case in point, I was part of the JavaPOS standard and it took a distributed team of more than 20 engineers (from more than 10 companies) greater than 5 years to create a specification (at 3K+ pages) for typical POS devices (i.e., Scanners, magnetic stripe readers, receipt printers, and so on) that could allow application providers to easily have their software working with different hardware vendors by simply changing an XML configuration file.

In the next (and last) post on the ooPSLA 2007 conference, I will continue the braindump of the interesting sessions I attended. This will hopefully include Brian Foote's talk on BIG BALL OF MUD; the workshop on domain-specific modeling/language; some of the Onward! paper sessions; the LINQ tutorial by Eric Meyjer of Microsoft; the Eclipse Jazz presentation by Erich Gamma of IBM Rational; a few of the panels I attended on software engineering, languages, and SOA; and some parting thoughts mingling with many interesting minds and colleagues in the field.

Monday, November 5, 2007

Why study computer science?

Recently, an old high-school friend, back in Port-au-Prince, who contacted me after visiting my Web sites, asked me the following question.

> Why did you study computer science (I am just curious)? I am clueless about technology, but it does fascinate me.

Since I thought this was an interesting question, I told her I would blog my answer. So here it is, with some minor updates to elaborate some points.
It's hard to briefly answer why I chose this field of study (computer science) and have dedicated much of my life and energy to help advance it --- albeit with small success so far... However, if I was pressed for a concise and quick answer, I would simply say:

I chose computer science as my primary field of study because the computer (or computing machine) is maybe the most flexible, complex, useful, and potentially dangerous man-made invention. While the field (and associated sub-fields) have created many pragmatic and useful applications in the 60 (or so) years of existence, the computing fields have also opened many unanswered scientific questions ranging from a pure theoretical nature (e.g., P = NP? and the limits of computation and artificial intelligence), social (e.g., the impact of the Internet on freedom of speech and governments, gaps between have and have-nots, and so on), as well as deeply personal and human (e.g., entertainment, education, privacy, and self-expression) to list a few.

As a more elaborated example, the Internet and the Web (which arguably spawned from the sub-fields of networking and software and hardware engineering) have forever changed all aspects of the fabric of human civilization and while mostly beneficial, the resulting changes are not always positive---the Web can be a great tool to exchange family pictures as much it can be used for propaganda.

Being in Silicon Valley at what is really the beginning and forefront of this revolution is truly exciting and invigorating. Being part of the research community, tasked to help advance the field is an honor and privilege.

Thursday, November 1, 2007

ooPSLA 2007 - part 1

ooPSLA 2007 in Montreal, Canada - Oct. 21 to Oct. 25, 2007

The 20+ year old conference on object-oriented programming languages systems and applications (OOPLSA) is easily one of the top computer science conference in the field. This is where key revolutionary, evolutionary, and influential ideas and technologies such as Java, Agile, Aspects, Patterns, UML, Eclipse, and DSL (just to name a few) were mostly first discussed in an academic and open industrial setting. The inventors of these ideas and technologies make ooPSLA a GOTO date on their calendars and typically give tutorial and take part in panels with colleagues on the subject.

Photo of Dick Gabriel and David Parnas during Parnas's keynote

That long history and the impact of the technologies and ideas that the conference has spawned make it a star conference to attend for anyone in the field. The fact that acceptance rate is usually extremely low (10% or so) also gives more value to any paper that is accepted there. However, unlike what the name suggests, ooPSLA is more than a conference on object-oriented technologies, hence why Dick Gabriel (IBM Research distinguished engineer and ooPSLA 2007 conference general chair) and other organizers have started to refer to the OO part in lower case, thereby correctly minimizing the importance of OO in the conference as a whole.

ooPSLA and me
In late 1997, during my first year of graduate school, I took Ed Gehringer's class on OO programming at NC State University, and Ed, as a long time OOPLSA participant, introduced us all to OOPLSA and the various technologies being discussed there at the time: Java, Smalltalk, Eiffel, Patterns, UML, and so on. I attended my first OOPSLA in 1999 (Denver, CO) and have attended them sporadically ever since (including 1999 in Dever, 2000 in Minneapolis, 2001 in Tampa Bay, 2002 in Seattle, and 2005 in San Diego). This year, after one year absence, I am back to ooPSLA and this year I also have a short paper and poster on my current research.

In a nutshell I created a domain-specific language (DSL) in the Ruby language for Web APIs mashups. Taking advantage of the Rails framework, the DSL allows a high-level representation of the various parts of what it takes to create a mashup. Using some Ruby metaprogramming magic, the DSL constructs are converted to a full RoR Web applications with necessary plumbing to connect to the Web APIs (i.e., REST, RSS, Atom, and APP) and to present views for user interactions as well as the back-end logic for service interactions. Ajith Ranabahu and I built the first implementation of the platform by the code name Swashup (Situational Web Applications Mashups). At ICSOC 2007, Hernan Wilkinson, Stefan Tai, Nirmit Desai, and I published a paper focusing on the DSL itself.

In a subsequent post, I'll outline some notes and highlights I have captured during this year's conference.

Tuesday, October 30, 2007

First California earthquake experience

I just experienced (Tuesday October 30th) my first real earthquake since I have been living in California. I was seating at Starbucks in Sunnyvale and getting ready to head to the gym after a long day working remotely, the whole place starting moving back at forth at around 8:05PM PDT.

It appears that the quake's epicenter was in Alum Rock, CA (about 15 miles from San Jose) and the official time was 8:04PM PDT and the magnitude was 5.6.

The first tremor lasted about 4 to 6 seconds. Enough to get everyone out of their seats and realizing we were in the middle of a quake... Most people starting moving to the exit door. I stayed at my seat since I was not about to let go of my Mac :-)

Then it happened again and then again. Though the subsequent ones were shorter and shorter.

Not sure what damages, if any, this little one caused---cannot see anything from here, all seems well. Regardless, one things for sure, you come out of this feeling like you are floating and living in a surreal state (still feel it more than 5 minutes since). Not sure if this is scary or cool...

Why I love Ruby?

Since I am a vocal advocate of the Ruby programming language and the various tools, frameworks, libraries, and domain-specific languages (or DSLs) that are mushrooming around it, I often am asked to explain the difference or similarities between Ruby and other languages, e.g., Java, Python, PHP, and so on; or simply people often asked me simply why I so vocally advocate Ruby?

To make it easy to answer such questions and shed some lights on the matter, I decided to aggregate my answers and refine my thoughts into a series of blog entries that attempt to shed light summarize the technical reasons and give you my personal views as to why I am such a fanboy of the Ruby programming language and of the grassroots movement that accompanies it.

(photo credit:

I hope this will be a conversation over the next months or so, and while I have at least 10 prepared reasons (posts) to answer this question, I plan to unveil them every other day week (or so) and refine them with real code examples or pointers.

I would love to hear your thoughts on the subject, so please feel free to add comments --- views in agreement or violent descents are welcome equally.

So without more introduction, here is why I love Ruby and why I think it is a programmer's and software researcher's best friend.

Minor updates on 11/18/2007

A mean and cool cat...

Initial thoughts and review of Apple's latest OS X update: Leopard

I have been using Leopard for three days now and I must admit that it was worth the upgrade and I would easily recommend it to anyone that uses a Mac or Windows for that matter.

The first thing that impressed me with Leopard is that my transition from Tiger was virtually seamless. I installed it on my MacBook Pro 17" and my Mac mini. The installation is straight forward but took about one hour to two hours for the Mac Book Pro.

Everything works!
(well almost everything)

That's huge. My experience with major upgrades of Windows and even Linux have always caused major headaches. Something always seems to cause issues or needs reinstall or get new drivers and so on.

For my case, I use my Mac for all software development (mainly Ruby/Rails and some Python and Java) and so far all of my Rails code works as if nothing had happened. Safari is even nicer than I recall and seems faster. Not sure if this has to do with underlying speedup, somewhat noticeable as well... All of my corporate applications also worked! that was my biggest fear --- loosing VPN connectivity. Sure enough all seems well.

I had two printers connected to my Mac Book and one of them needed to be setup anew, other than that, the only minor glitch was from an application called Aurora (an alarm application) which would crash on startup. The Aurora publishers promptly pushed an update on Monday that seems to have fixed everything.

Besides this nice surprise of having all network connectivities, development applications, and corporate software working fine, the best things about Leopard are easily: 1) the new, 2) quick view and cover flow in finder, 3) Time Machine, and 4) a slew of small but nice touches
Really really nice. My favorite features are: 1) additions of RSS/Atom feeds into your mailboxes and items and entries are presented like mail items, 2) TODOs and Notes, 3) Quick and easy creation of TODOs from mail, feed, and other content, 4) mail templates to make it easy to create some mails, e.g., email with photos attached.

Quick View and New Finder
Most files now come with a thumb print preview and can be fully previewed by clicking the space bar. This feature is also directly incorporated into the new Finder. However, perhaps the best new feature of the Finder is that (like Mail) you can have virtual folders (or smart) folders that allow you to see items based on some set of rules. For instance, all files created today, yesterday, this week, and so on. This is not only convenient but it's fast and with the quick preview feature, this makes finding files you worked on a breeze... (I think Vista had something like this as well)

Time Machine
Minimalist but powerful backup solution. As simple as specifying a backup volume and clicking On. Everything happens on the background and when you need to recover a file, just go to where you may be missing file or data and click the Time Machine icon.

There is a nice metadata touch on Mail where if you put your mouse near the text Today, Leopard will recognize that this is a date and allow you to create a meeting or TODO.

There is a nice help menu search feature incorporated in all applications. You can now search in the Help menu of all applications and Leopard indexes all menu items and will point you to the right menu (cascading and opening any super and submenu to make the one you searched for visible).

Built in VNC (virtual network computers) to all Leopard fitted Macs. This allows you to remotely access and use your Mac. Apple advertises that this can work over the internet using .Mac. I have not been able to try that with my Mac mini. Maybe it won't wake up the system if sleeping... At home it worked fine and was easy, but this is nothing really new.

The built in pager (Spaces) is nice in that it allows you to quickly move applications from one space to another. Other than that, everything I had with Desktop Manager remains active.


All in all Leopard is a cool update for anyone. It provides compelling reasons for Windows users to switch. For developers (especially Web developers) and researchers, this is a Web friendly update. Ruby and Rails come built in, as are Java and Python, and all of the Apple development tools. Since the Web design and media tools are legendary on the Mac, this is more reasons to move to that platform if you do Web development. Especially since Safari and Firefox work perfectly on the Mac.

The only annoyance that I have found so far is that iTunes seems to skip a bit when I am using it while doing my day to day activities... this was always something that I loved about my Mac and that Windows never got well. No matter what I was doing with Tiger, iTunes never seemed to skip... However, this cat seems to be hesitant a bit. Hopefully, Apple releases an update to iTunes soon enough to fix this annoyance and add another black spot to this cool cat :-)

Wednesday, August 15, 2007

Agile 2007

I am in the nation's capital today to present a co-authored paper on Test-Driven Development (TDD) at the Agile 2007 conference:

J. C. Sanchez, L. Williams, and E. M. Maximilien. A Longitudinal Study of the Use of Test-Driven Development Practice in Industry. In Proceedings of Agile 2007 Conference, pages 5-14, Washington DC, August. IEEE Computer Society. [ paper | presentation ]

There are a few groundbreaking results in this paper:

  1. It's the first of it's kind with results spanning five years of continuous usage of TDD

  2. We have empirical evidence that using TDD reduces the defect-density for almost every release

  3. We collected data that lead us to hypothesize that using TDD may reduce the complexity of software over time. As far as we know, we are the first to make this observation and have data to back it up

Overall, the presentation was well received, with lots of interesting questions. InfoQ was present and recorded it. I'll post the podcast and videocast links as soon I get them.

Wednesday, July 25, 2007

ICSOC 2007

I will be attending the International Conference on Service-Oriented Computing (ICSOC 2007) in Vienna, Austria on the week of September 17th.

Not only is ICSOC a top notch academic conference (with ~20% acceptance rate) but the location is not too shabby either. Vienna a city with a rich culture, history, and far reaching political influences over the years. It is located in the middle of Europe and borders eight other European nations.

Some of my planned activities include:

  1. Tutorial entitled Web APIs and Services Mashups using Ruby and RoR. See also my tutorials page for slides and code samples. Though keep in mind that they will likely be updated for September

  2. Mashups'07 workshop. See also this blog entry

  3. Presentation and demo for paper entitled A Domain-Specific Language for Web APIs and Services Mashups

If you plan to be there then definitely drop me an email so we meet.

Thursday, July 12, 2007

On the nature of work... or what's the relationship between Mozart, Parkinson, and agility?

Does more time lead to better work?
"I need an extension to submit my paper" Jane asks. "OK, but I can only give you one more day" Peter replies. "Well, if I had one more week, the quality of the paper will be significantly better..."
How many times have you heard similar conversations or have been part (on either side of the fence) in some similar debate. Not just for writing but any types of creative works. In today's continuous work environment and Web time, does more time lead to better work?

A positive answer to this question would seem to imply simply that one would spend more time on the tasks at hand, revising, researching, and improving it, now that one has more time... interesting. In Software Engineering there is a principle called (interestingly enough) Parkinson's law or principle that says (paraphrase) that total work tends to grow to fill the time allotted. This phenomenon, known for decades, and observed in many contexts and certainly in software, helps explain a lot of why software tends to be late, along with other human tasks... The rational for why the Parkinson's law applies so broadly has to do with human nature and also to the dynamics of human tasks and their non-linearlity. In particular the non-linearity of human inspirations (important). I believe that this principle is universal to any type of creative works.

Now this may not be your case. However, for me, any deadline extensions means that I end up pushing some of the work later and address other top priority items now. Naturally, sometimes it could also mean that I spend more time on a given item and improve it's quality. However, in almost 90% of my tasks I am starting to be like (unfair comparison though more like an aspiration) Amadeus and deliver my tasks (papers, code, presentation, and so on) without much revisions---basically as they came to me.

Again, not to compare one with the genius of Mozart, aspiring to be like him though maybe a cool thing. We are all stretched thin and under pressure, so learning how to get things done the first time and also done well is a skill that can pay really big, though clearly also incurs a certain amount of risks that could cost dearly.

The agile software development movement solve this problem in a similar fashion while reducing the risks with delivering tasks without revisions and by reducing wastes. Essentially, in agile methodologies, iterations are an integral part of all tasks while early-and-often delivery is also a primary activity. Agile teams deliver their tasks quickly and revise them often while focusing on what is more important at the time by allowing the stakeholders to drive (i.e., direct the priorities) which help reduce efforts that are not important or potentially wasteful.

Can this approach be successfully applied to other human tasks? Is this a good thing? Are there alternatives that also allow one to remain competitive?

Friday, July 6, 2007

Thoughts on enterprise mashups...

Are mashups good for enterprise integration? Do enterprises need mashups?

There is a real danger in thinking of mashups as just another tool in the enterprise IT integration mess. What I mean is that Web services have loss a great deal of their simplicity as they moved quickly to help solve enterprisey issues (read as mainly non-functional attributes), e.g., SLAs, reliability, scalable data and event sharing, transactions, some aspects of security, and so on... Entered, the so-called WS-* set of standards.

So far (as far as I know) very few enterprises actually use WS-* to re-engineer or implement their enterprise IT systems. The complexity of the "standards" is one of the main factors to this lack of success. Instead, I believe that enterprises still rely on tried and true and proven technologies such as relational DBs, message queuing systems, and so on, and expose simpler Web services or Web APIs at the edges for integration. For instance, Atom or RSS data services and REST services when business processes need to be exposed.

I fear that the same complexity tar pit will engulf mashups if we rush and attempt to try to make them the next "silver bullet" for enterprise integration...

Mashups have a place in the enterprise but in my view it's rather limited and is related to the more social and community aspects of enterprises (internally and with external companies and events). Stefan Tai's (IBM T.J. Watson) service community research project was the first to hint at this trend.

Mashups can be a great edge integration technology for enterprise services, whereby most of the complexity-prone non-functional attributes (other than security) are not directly addressed by mashups and instead provided by and relied on by the lower-level enterprise software stack, which have (slowly) addressed these non-functional issues over time.

Finally, on a grander scale this edge integration thought is happening *now* for small-to-medium enterprises and also is becoming more relevant as back-end enterprise systems are hosted by large services in the cloud, a la and Amazon Web services. When these hosted services become mainstream then mashups and associated technologies may become the glue for software innovations at companies small, medium, or large.

Let us resist the dark side and not let mashups and associated technologies become the next WS-death *

Thursday, July 5, 2007

Mashups'07 Workshop at ICSOC 2007 in Vienna, Austria

Stefan Tai, of IBM T.J. Watson Research Center, Dave Nielsen of StrikeIron, Inc., and I are organizing Mashups'07 Workshop at ICSOC 2007 in Vienna, Austria on September 17, 2007. The Call for Papers and Demo is posted and the dealine is July 15th.

We have a great varied Program Committee composed of industry leaders (e.g., Google, Yahoo!, Adobe, and so on) as well as Academia (e.g., NC State, Stanford, and UC Berkeley) from both computing and business schools.

Finally, we are experimenting using a content mashup tool called Highlightr during this meeting for discussion, sharing, and mashing content.

Highlightr is an example application built using our Web 2.0 (situational applications) and Web APIs mashups research project at IBM Almaden called Swashup (built in Ruby and RoR). We also have a paper and demo of this project that we will present at ICSOC 2007 in September 2007 in Vienna.

Friday, June 29, 2007

iTerm tips

If you use Mac OS X for development and you do not know about iTerm then get it now... iTerm is open source, supports tabbing, and many other features.

Now, I have been using iTerm for a long time and it bugged me that I had to setup the title and tab via GUI options. Well, found this great tip on how to customize the tab and title windows. Very cool.

So finally decided to start blogging again...

No, it's not due to the so-called JesusPhone released today but rather due to the fact that I am spending too much time answering similar questions here and there. Hoping the blog could help me have a sort of FAQs list.

Of course, the best reason is to allow for a place for public random thoughts and feedback.

Hopefully I get to post regularly