I realize it all makes sense, but there is something terribly off-putting about xml. To me it’s a sign that the host language is not sufficiently dynamic or declarative, and here we are going back to a verbose format so that the framework can parse it using readily available libraries. It also makes one yearn for a lispy language, where configuration and implementation code looks entirely similar.

All this language snobbery may be well and good, but it doesn’t help to improve one’s familiarity with an important framework.

This brings me back to the original comment about how to read Lisp code. If you stare at it long enough, the braces simply disappears.

This is exactly what I had to do to learn new XML configuration file formats. Stare at XML long enough, and the tags simply disappear.

If you are willing to persist with the equivalent of staplers in your cereal bowl, here is what xml looks like to you after a couple of months:

<hibernate-configuration>
   <session-factory>
     <!-- SQL dialect -->
      <property name="dialect">org.hibernate.dialect.HSQLDialect</property>
      <!-- Database connection settings -->
      <property name="connection.driver_class">org.hsqldb.jdbcDriver</property>
      <property name="connection.url">jdbc:hsqldb:data/music</property>
      <property name="connection.username">sa</property>
      <property name="connection.password"></property>
      <property name="connection.shutdown">true</property>

      <!-- JDBC connection pool (use the built-in one) -->
      <property name="connection.pool_size">1</property>

      <!-- Enable Hibernate's automatic session context management -->
      <property name="current_session_context_class">thread</property>

      <!-- Disable the second-level cache  -->
      <property      name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>

      <!-- disable batching so HSQLDB will propagate errors correctly. -->
      <property name="jdbc.batch_size">0</property>

      <!-- Echo all executed SQL to stdout -->
      <property name="show_sql">true</property>
      <!-- List all the mapping documents we're using -->
      <mapping resource="com/oreilly/hh/data/Track.hbm.xml"/>
   </session-factory>
 </hibernate-configuration>

What’s your way to cope with xml? Any tips?

clojure.core/merge-with
([f & maps])
  Returns a map that consists of the rest of the maps conj-ed onto
  the first.  If a key occurs in more than one map, the mapping(s)
  from the latter (left-to-right) will be combined with the mapping in
  the result by calling (f val-in-result val-in-latter).

Using merge-with yields a rather terse code, comprising a tree-walker and a final tally.

(defn count-syms
  "count number time of a symbol occurs in the first place of a sequence"
  [obj]
  (if (not (seq? obj))
      {} ; only count sequences
      (do
        (reduce #(merge-with + %1 %2)
          (conj
            (map
                count-syms
                (filter seq? (rest obj)))
            (inc-dict dict (first obj)))))))

sym	count	len
clojure.core/list	3872	17
quote	2749	5
defn	1757	4
clojure.core/seq	1481	16
clojure.core/concat	1480	19
=	1074	1
let	1042	3
is	885	2
.	836	1
if	826	2
defmethod	431	9
def	407	3
complex	377	7
defn-	376	5
fn	356	2
first	346	5
defmacro	298	8
clojure.core/apply	264	18
deftest	257	7
str	252	3
when	244	4
imaginary	238	9
recur	237	5
apply	229	5
instance?	220	9
nil	217	3
and	214	3
next	208	4
cl-format	206	9
fn*	197	3
ns	194	2
map	193	3
:use	187	4
list	184	4
1	181	1
count	178	5
+	169	1
seq	167	3
reduce	165	6
are	148	3
cons	143	4
println	141	7
or	141	2
not	135	3
loop	133	4
thrown?	127	7
*	127	1
conj	125	4
print	124	5
nth	124	3
-	116	1
doseq	114	5

Now, I have a study-plan.

Incidentally, waterfront IDE is quite nice, particularly because I don’t have to learn Emacs key-bindings. There are some moments when it barfs and prints out hashmaps incorrectly, but I enjoyed working in a REPL environment.

What I find interesting about Scheme macros is that it uses the ellipsis (…) very intuitively when expanding macros.

For instance

[code lang="Scheme"]
;Next line for Guile only
(use-syntax (ice-9 syncase))
(define-syntax repeat
(syntax-rules ()
((repeat a1 ...)
'((lalala a1) ...))))
(display (repeat pork-chops roast-beef beetroot cheese))
[/code]

This macro matches for the pattern (repeat a1 a2 a3 etc …). The macro expansion is written this way: ((lalala a1) …), with the ellipsis written outside the brackets containing a1.
The end result is the list gets “unrolled”:

[code lang="Scheme"]
((lalala pork-chops)
(lalala roast-beef)
(lalala beetroot)
(lalala cheese))
[/code]

This style of notation makes for easy equivalents of Python’s “zip” function.

[code lang="Scheme"]
(define-syntax zip
(syntax-rules ()
((zip (a1 ...) (b1 ...))
'((a1 b1) ...))))
(write (zip (1 2 3 4 5 6) (a b c d e f))
; yields
; ((1 a) (2 b) (3 c) (4 d) (5 e) (6 f))

[/code]

Now, if only computer science professors could learn to write like this teenager. Don’t you think Will’s tutorial on syntax-rules make the intention and usage clear?

Kudos, Will. Subscribed.

Dave Herman has thought through some of the practicalities of using declarative languages, particular when a complex system has to be broken up into modules. This leads to problems like overriding, specificity of rules, recursion.

Other problems with DSLs include

1) difficulty in debugging. It is hard to debug data, add breakpoints

2) difficulty in showing derivation of results.

3) error handling is hard

Say you’re in the kitchen in front of the refrigerator, thinking about a sandwitch. You take a continuation right there and stick it in your pocket. Then you get some turkey and bread out of the refrigerator and make yourself a sandwitch, which is now sitting on the counter. You invoke the continuation in your pocket, and you find yourself standing in front of the refrigerator again, thinking about a sandwitch. But fortunately, there’s a sandwitch on the counter, and all the materials used to make it are gone. So you eat it. :-)

In trying to come up with a classical conceptual model in which to capture these non-classical phenomena, we eventually hit upon using the idea of using computer games as an analogy. The exact choice of game is not terribly important, but let us pick Tomb Raider – a popular game from about ten years ago (back when I had the leisure to play these things), in which the heroine, Lara Croft, explores various tombs and dungeons, solving puzzles and dodging traps, in order to achieve some objective. It is quite common for Lara to die in the game, for instance by failing to evade one of the traps. (I should warn that this analogy will be rather violent on certain computer-generated characters.)

Via Will Farr Via Planet Scheme

(Ferret was originally a port of Lucene, but recent alteration to the file format has increased performence 5x over GCJ, and then the author ported to C to get an order of magnitude improvement.)

The moral of the story is not one of premature optimization, but working with pliable languages vs working with brittle ones.

Not bad for a Lisp newbie. (grin)