Summary
A collection of miscellaneous observations and my "Best Of" awards.
Advertisement
Observations
As Anil Hemrajani noted, Rails configuration files are
actually ruby files. They even end with a .rb extension.
So they can include any code you need to handle dynamic
configuration. That's pretty cool.
Ruby is nice because (as Anil also noted) the same
language can be used either for a serious OO application
or for a simple script. That makes one language to
learn, with many possible applications.
But that dual-use capability is rapidly becoming the
only reason left for preferring Ruby over Scala. There
was the ability to create DSLs, but Scala seems to be
all over that one with functional composition. And the
real killer app was Rails, but the Scala's Lift framework
looks like serious competition on that front. (See the
resources.) That leaves my favorite build language, Rake.
And the ability to write simple scripts. And of course,
there is the small matter of dynamic typing. But do I
really need that, if the language is as flexible as
Scala?
Awards
The award for Loudest Applause at a non-keynote session
goes to Todd Fast, from Sun. His talk centered on the long
tail of user-constructed applications. But that summary
doesn't do justice to the masterful way he deconstructed
the space. The main points were:
Platforms like FaceBook, MySpace, Ning, and Meebo
provide high levels of abstraction in their application
models, making it easy for non-programmers to do stuff.
OpenSocial provides a common API people can use to
write such applications
Social networking applications grow virally. Your
friends use it. They tell their friends...
An application can take off very fast--to the tune
of 250 thousand users a day. And they can drop
off just as rapidly, as people turn their attention
to other things. So maybe "disposable
apps" are the wave of the future (eventually).
20% of earth's population is on the web today.
Approximately a seventh of them are doing social
networking. So the potential is huge.
Clay Shirke identified the Cognitive surplus that
will likely produce the long tail apps. That surplus
is pretty huge, when you consider that approximately
100 million hours of human thought went in Wikipedia,
but 200 billion hours are spent watching TV every
year--that's the equivalent of 2,000 wikipedia projects
per year. Given a proliferation of higher-level application
models that anyone can use, there is the potential
for explosive growth in the application domain.
Another really good session was given by Dean Allemang, author
of Semantic Web for the Working Ontologist. (See Resources.)
It was the best explanation I've seen yet of RDF and its potential
applications. The key points:
RDF is basically subject/predicate/object -- like a basic
sentence, where the predicate is the verb that links the
subject and the object.
In the semantic web, the subjects are URIs.
In effect, each triplet identifies a cell in a gigantic table.
The cells are joined by subject-URIs to create "rows".
(They could conceivably be jointed by joined by predicates
to create "columns", as well.)
OWL equivalences can be used to map locally-desirable
nomenclature into a common ontology. (The Dublin Core is
a standard ontology that was created to catalog library
contents. One of the 15 standard items it defines is
"creator". The namespace is "dc", so "dc:creator" specifies
that entry in their ontology. Using OWL equivalences it
becomes possible to map book:author and play:playwright
to dc:creator--so the common meaning is identified while
separate terminology is maintained.
That's a really big point. As Allemang pointed out, the
idea is not to somehow get everyone to agree on one big
giant vocabulary. (Good luck.) Instead, The idea is be able
to identify the vocabulary someone is using, map terms that
mean the same thing and distinguish terms that mean something
different. Namespaces do the distinguishing, and equivalences
allow for mapping.
Once the mappings are defined, it becomes possible to do
searches and interesting mashups--all of which help to
enable "long tail" applications.
The award for Best Service goes to the entire staff of
the Moscone Convention Center, who were unfailingly
as helpful as they could possibly be.
The award for Best Swag goes to Oracle, who gave out
tickets to see IronMan. (A fact I discovered only
just too late!) They even included coupons for drinks
and snacks.
The award for Coldest Venue for a rock concert goes to
Yerba Buena Gardens, where SmashMouth gave a show for
a freezing conference crowd. (There should have been more
dancing, so we could stay warm!)
The award for Best New Technology may just have to go
to Scala. Although it's not exactly new, it certainly
provides the majority of features that are near and
dear to a Rubyist's heart. Then there is its static
typing, which does eliminate a whole class of runtime
errors, while also making it easier to write a refactoring
IDE. And mostly, I get the idea that things just seem to
work. I'll have to join the Scala list to confirm that
one. (You can get an amazing sense of things by lurking
for a week or so.) If it's as solid as it appears to be,
and Lift is as cool as it looks, it just may take home
the award.
Well, that's all for this year.
See you again in 2009!
Previous Topic
