Zef Hemel

It's interesting that you mention Javascript. There was recently a post on CoffeeScript that hit the frontpage, and one reference it linked was to a point of contention between CoffeeScript's developers and a library creator over whether CoffeeScript should introduce a nontrivial amount of wrapper code to support attribute setters and getters [1]. The library author made the following argument:

For CoffeeKit specifically, the getters for all accessor
properties are totally without side effects. They are getters
because they have to wrap access through objective-c selectors.
I can't make them fields. I also can't in good conscience
make them all functions, requiring people to write:

uikit.UIScreen.getMainScreen().getBounds()

instead of:

uikit.UIScreen.mainScreen.bounds

yuck.

This, however, speaks directly to the point at hand: one could argue that a library creator in good conscience should make them all functions, since it would force library users to "reason about performance." It's tempting to remove extra syntax whenever possible, but sometimes verbosity can reduce technical debt insofar as it encourages developers to think about performance.

Ruby on Rails definitely leans towards reducing verbosity, but it has such a good ecosystem that even though I'd like a platform that makes things a bit more apparent about what things have/don't have side effects, it's still the best option for many projects that need to…

> how you do we (container creators) know the dependency tree for the app

Nix package manager [1] offers a potential means to know the complete dependency tree. If you're not familiar, a nix expression to build a package takes a set of inputs (specific binary packages of, e.g., make, gcc, bash, libc, libxml2) and produces a binary output (depending only on the inputs). The run-time dependencies can be a smaller set than the build-time dependencies and are deduced by observing shared library linking for example.

I've been using it (outside Docker) for various Ruby apps, and I can't say it's been easy, but a large part of the pain has been Rubygems' inability to encode dependencies on C-libraries (e.g. libxml-ruby depends on libxml2).

There have been attempts at provisioning Docker containers with Nix [2]

Of course, if you are using Nix, some part of Docker's isolation becomes redundant (Nix isolates multiple version of things on the filesystem using plain-old-directories, so it's trivial to run ten different versions of Ruby side-by-side, for example).

[1] http://nixos.org/nix/
[2] http://zef.me/6049/nix-docker/

I like many of the state of the art frameworks, especially backbone.js and I'm really thankful for how much impact they had on making complexity in web apps manageable. That said I absolutely agree with you regarding the fragmentation problem which seems more like a stack problem to me.

For me personally it looks like what the web desperately needs is a common ground for how widgets work and behave. Web Components look like what we will get and I really can't wait to see that happen:
https://dvcs.w3.org/hg/webcomponents/raw-file/tip/explainer/index.html

Here are some examples from Dart Web UI (web component polyfills for Dart) http://www.dartlang.org/articles/dart-web-components/

Also here is a great article about the web stack fragmentation that you might be interested in:
http://zef.me/4835/dart-web-fragmentation-vs-web-development-fragmentation

Exciting times,
Thomas

Ok, for example, this morning I've gone through: http://zef.me/2913/javascript-oop-style-performance http://cairnarvon.rotahall.org/2010/02/28/search-trees-are-e... http://norvig.com/sudoku.html http://en.wikipedia.org/wiki/Knuth%27s_Algorithm_X http://www.topcoder.com/tc?module=Static&d1=tutorials... http://www.extjs.tv/index.php/2010/javascript-debugging-tech...

I suggest reddit.com/r/programming, Hacker News obviously, and YourVersion.com for finding new stuff to read based on your interests, and then you can usually find more to read without too much trouble. There is always more!

> I'm talking about completed, tested, accepted features, as defined by our project teams.

Still rather strange metrics for productivity in a senior engineer. This is more what I'm taking about: https://zef.me/the-100x-engineer-6d50a690a866

If you're really senior, you shouldn't be working on the kind of features that get delivered at a rate of "5 per sprint". More like on stuff that gets delivered once every year. The junior SHOULD outperform you in "code produced" - they just shouldn't outperform you in dollars produced (or saved).

I'm tickled that their build system, a slicker replacement for Ant, is called Leiningen.

http://zef.me/2470/building-clojure-projects-with-leiningen

It's a reference to the classic short story "Leiningen versus the Ants", which is a good read:

http://www.classicshorts.com/stories/lvta.html

And the build system looks nice. It has the pleasant feeling I get from scons, with the advantage of being Clojure-specific, so common Clojure tasks are easy.