Node.js and the Javascript Tools Ecosystem

I recently have been picking up some javascript tools to test the waters of "serious" programming in that language (browser-side or otherwise). Although I've not used node.js yet for application development, it curiously shows up in several javascript-based shell tools.

And it works fine so far. My initial impression was, "Why use a web server to run shell tools?" But, e.g. docco installed perfectly using node.js and npm.

Being a skeptic, I first tried pycco, a a similar tool but more traditionally installed pythonically. Something wasn't right and it didn't run. This is just one, unfair, data point. But it was a reassuring experience that javascript tools are showing up and working fine.

Another javascript tool installed and run using node.js and npm is PEG.js, a parser generator based on, well, PEGs (parsing expression grammars).

These tools run fine, and I'm thinking they startup much more quickly than the java-based rhino javascript runtime tools. I've not bothered to investigate though.

This is not the one: On Lisp

This is not the post I'm going to write, but it is the one I'm writing.

I recently saw a tweet that reads something like, "Nice presentation on Clojure, but any language where you write 1 + 2 as (+ 1 2) is not for me." Fair enough. I won't hold it against you if you share that sentiment.

What about a language where you write 1 + 2 + 3 + ... + 1000 as:

(apply + (take 1000 (iterate inc 1)))

Lisp may seem foreign at first. And looking at a small expression in your language compared to the same in lisp may turn you off lisp forever. Fair enough.

Maybe your language has something equally as expressive. Fair enough.

But lisp is more than prefixes and parentheses, and you may want to dig deeper into the benefits of all of lisp's characteristics. Fair enough if you don't.

Is This Thing On?

Hi! (Insert animated gif of that guy digging. "Under Construction" - I'm working on a new blog post...)

Jobs of the Not-Steve Kind

An interesting graph of jobs related to some relatively hot programming language...

scala, groovy and java, erlang, haskell Job Trends

scala jobs - groovy and java jobs - erlang jobs - haskell jobs

David Gelernter re: programming for/with clouds, etc.

"the reason why our approach was considered radical and strange in the
1980's was the so-called Tuple Space Model — the idea being that if
you had a lot of computing agents who needed to communicate, instead
of sending messages to each other, essentially like e-mail, if I had
information for someone, I'd just write it on a piece of datum and
release it and it would just float up into the cybersphere. If I
needed information, I'd look around, grab whatever I want, I would
read it or, if it were a task to be done, I'd grab it so nobody else
could grab it. "
-David Gelernter

http://www.edge.org/3rd_culture/gelernter09/gelernter09_index.html

(still beats the pants off all that crap we call integration
technology today. -me)

On Clojure, Testing the Implementation, and Protecting Your Investment

Over on the Object Mentor blog, Dean Wampler writes about the Clojure
programming language and the designer's stand on testing the
implementation. Dean writes that...

"TDD provides two important benefits
* Driving the design.
* Building a suite of automated regression tests. "

But another important benefit of a good collection of tests is communication.

Clojure is a fine Lisp in many ways. I personally would hesitate to
use it for anything in which I had a significant investment given the
maintainer's stand on testing. At least not without a good deal of
evidence that Clojure will continue to be maintainable and understood
(at the implementation level in particular) by more than one person.

Maybe his approach will work over a long period of time, and for a
user community that will rely on Clojure for many heavy-duty, valuable
production uses. I cannot say that it won't.

I can only say that for _me_ this would be a significant reason to
hesitate before taking too significant of a plunge.

And that's saying something because I am a veteran of programming in
various Lisps for 29 years, and Lisp generally is my favorite
language. I love that Clojure has rejuvenated interest in Lisp.

http://blog.objectmentor.com/articles/2009/06/05/rich-hickey-on-testing

TriSano: "Best Project for Government"

Click on this badge to vote for TriSano for "Best Project for Government"...

XPDX April: Bugs Do Not Exist

This month's http://xpdx.org meeting...

http://calagator.org/events/1250456971

Chris Sterling and Michael Tardiff are coming to Portland and will be
running April's XPDX session:

"We know about items on the product backlog, and getting them to
"Done." We know about impediments, and removing them as soon as
possible. And agile methods lead us toward shipping software with zero
defects, we hope. But bugs remain, for now, and we think of and treat
them quite differently from stories, tasks, and other work
items—perhaps to our, and our project's, detriment.
Buy why? We need your help finding an answer, or posing better questions.

In this interactive session, we'll explore the wealth of thoughts,
opinions, and especially the strong feelings behind the things we call
bugs."

>>> Pizza is sponsored by YesMail <<<

Pizza arrives at 6:30pm, the session starts at 7pm, and at 9pm we move
on to a local bar.

CHIFOO: Workshop: Interaction Design & Agile Development Techniques

From the xpportland yahoo group...

"Jeff Patton is giving a one-day workshop on user-centered design and
agile methods, organized by CHIFOO. The notice is below, in case
you're interested."
-Arlo

Come join the Computer Human Interaction Forum of Oregon (CHIFOO) for
a full-day workshop with two leading UX designers and Agile
Practictioners...

All Together Now: Blending Interaction Design and Agile Development Techniques

Lane Halley and Jeff Patton will lead a fast-paced day of fun and
learning. Through a combination of lecture and hands-on exercises, you
will increase your understanding of both User-Centered Design (UCD)
and Agile methods and gain useful techniques you can use immediately.

In this full-day workshop, you will learn how to:
• Choose appropriate UCD and Agile development techniques for your needs
• Successfully collaborate with diverse teams
• Understand who your "user" is, and what he or she values
• Create compelling design concepts that are shared by the entire team
• Iteratively sketch solutions as a group
• Translate design concepts into smaller user stories that can be implemented
• Prioritize and sequence product construction, without losing sight
of the "big picture"

This workshop is appropriate for people working in the UCD field, as
well as people curious about UCD or Agile.

Register Now for Lane Halley and Jeff Patton's Workshop

Registration is now open for Lane Halley and Jeff Patton's May 7, 2009
Workshop, "All Together Now: Blending Interaction Design and Agile
Development Techniques."

CHIFOO members receive a $50 discount off the price of the workshop!
Visit www.chifoo.org

My Earliest Reference to Erlang (So Far?) - It's Been >10 Years!

I started playing with Erlang and Haskell around 1998. Wow. Over ten years ago. I recently came across a post that may be my first on Erlang. It's to the Squeak list, suggesting Erlang might be seen in the same "message-passing" family of languages as Smalltalk. Someone had written, "I would like to create an application which runs seamlessly across multiple machines and platforms, but it's too hard because the communication and coordination is a bitch.". I replied...

Another approach is the simple message passing approach. This would be interesting to consider, given Alan Key's recent email to this list about "messages" vis-a-vis "objects".

Consider the programming language named Erlang from Ericsson. It is a concurrent and distributed language with no shared memory. All communication is by sending high-level messages. Receivers can pattern match on messages with time outs, etc. What Erlang calls "processes" can be linked to each other for high level process control and reliability.

There are several production-quality communications programs built with hundreds of thousands of lines of Erlang code, so it seems to have some practicality, which may meet the "lots of gain" requirement. The simplicity of it seems to meet the "little pain" requirement.

Apollo Workstations: Programming Interprocess Communication

This was sitting in a tab in Safari. I don't remember how it got there. It is a pdf of an Apollo document from 1985. Maybe it was from reading Steve Vinoski's latest RPC, etc. stuff - Steve worked at Apollo.

Maybe you're interested in reading it, maybe not. Apollo workstations were the first true "the network is the computer" computer, predating SunOS. I used them at Boeing and at Mentor Graphics in the 80's and 90's.

The CAD tools I worked on at Mentor Graphics used mailboxes to communicate between components, e.g. back end simulation engines and front end graphics. Note that Pascal is the systems programming language for Apollo.

(Programming Language Evolution?)

I'm not sure I will ever understand this obsession with "lisp has
parentheses". (http://bitworking.org/news/419/programming-language-evolution)

Jesus: "Dear god, we cannot use lisp. It has parentheses! Please
deliver us from evil."

God: "OK, my son. Here's ruby. It's a hack. Try writing a correct
parser! There's no 'there' there. St. Peter and I gave up. We found it
more soothing to go back to lisp."

Dynamic Language Symposium 2009

The 5th Dynamic Languages Symposium has issues its CFP. Funny
description though, seeing Python, Ruby, PHP, and TCL listed as "a new
generation".

Clojure? Yes, a new generation.

PHP? Ruby? They're now parents. Smalltalk and Lisp are grandparents.

http://www.hpi.uni-potsdam.de/swa/dls/dls-09/

"The 5th Dynamic Languages Symposium (DLS) at OOPSLA 2009 is a forum for
discussion of dynamic languages, their implementation and application.
While mature dynamic languages including Smalltalk, Lisp, Scheme, Self,
Prolog, and APL continue to grow and inspire new converts, a new
generation of dynamic scripting languages such as Python, Ruby, PHP,
Tcl, and JavaScript are successful in a wide range of applications."

Wiki 14th Birthday

Today is the birthday of Ward's first wiki. 14 years ago. Wow... I see some familiar names from that first day... Patrick Logan (oh, hey!), Patrick Mueller.

Learning from Mistakes — A Comprehensive Study on Real World Concurrency Bug Characteristics

From http://pages.cs.wisc.edu/~shanlu/paper/asplos122-lu.pdf

Some of our findings are as follows: (1) Around one third of the examined non-deadlock concurrency bugs are caused by violation to programmers’ order intentions, which may not be easily expressed via synchronization primitives like locks and transac- tional memories; (2) Around 34% of the examined non-deadlock concurrency bugs involve multiple variables, which are not well addressed by existing bug detection tools; (3) About 92% of the examined concurrency bugs can be reliably triggered by enforcing certain orders among no more than 4 memory accesses. This indi- cates that testing concurrent programs can target at exploring possi- ble orders among every small groups of memory accesses, instead of among all memory accesses; (4) About 73% of the examined non-deadlock concurrency bugs were not fixed by simply adding or changing locks, and many of the fixes were not correct at the first try, indicating the difficulty of reasoning concurrent execution by programmers.

Apache Cloud Computing Edition

Something Steve Loughran is taking with him to hackathon...

"Slideware on my proposal for an Apache Cloud Computing Edition; an
application stack from Apache to provide the app layer for all the low
level infrastructure-on-demand hosting services. Someone has to do it,
and who else is up to it?"

Interesting idea.

On Accidentally Pulling The Scroll Bar Off Your Mail System

Dan Ingalls on simple, dynamic languages and systems like Smalltalk or Lively Kernel vs. the typical language and "API" stratification...

Lord knows you can get the Google Web Toolkit and start cranking out Java code for doing these things [browser-based applications]...

...You can't go in a grab hold of part of it and pull it out or change it the way you can in our system...

Now at times you don't want that. You don't want people accidentally pulling the scroll bar off their mail system. But my philosophy has always been: Make it first dynamic and malleable and then you can always turn off those capabilities. But you're in much less of a position to go forward in the world if you start out with stuff that can't be changed.

$1T with a T

Fwd: [xpportland] XPDX Wednesday March 18th: Ping Pong Pairing

---------- Forwarded message ----------
Subject: [xpportland] XPDX Wednesday March 18th: Ping Pong Pairing
To: xpportland@yahoogroups.com

Pair Programming has many benefits for a team above and beyond coding,
yet it's still one of the hardest XP practices to get into. Ping Pong
pairing is a lot of fun and is my favourite way to pair. It has a
game-like style that instils good pairing and TDD practices. So come
along to the next XPDX meeting to try it out. It doesn't matter if
you've been pairing for years or want to try it for the first time. This
will be a chance to learn from each other. We'll spend a little time
getting to know the mechanics of Ping Pong pairing, do a brief
demonstration, and then all pair up for over an hour of practice.

Absolutely positively bring a laptop with you. We'll be using Java,
JUnit, and Eclipse. A big time saver will be to ensure that you have the
Java *SDK* installed beforehand.

>>> Thanks to VersionOne there'll be pizza for thirty! <<<

Be there at 6:30pm for the pizza. We'll start at 7pm. At 9pm we'll move
on to a local bar.

Wednesday, March 18, 2009 @ CubeSpace. Details on Calagator:
http://calagator.org/events/1250456785

This Just In: Functional Programmers Can Now Access Memory (Experimentally)

OK, type fanatics, get beyond my inflammatory headline already!

Actually, LtU points to an interesting paper (for some) on a bit of progress toward type systems for describing the correct use of resources.

Globals! Memory! Files!

As one comment points out, the pragmatic benefit of this work is sometime out in the future. Type systems will be good when they add more than they subtract.

They're not there yet, but there's (some) progress.