wallfly

The "name" tagging is great news. Thanks!

Jesus Christ, King of Mercy and Justice, teach us how to love the cross and the poor, and to humbly build your Father's kingdom with faith, hope and charity.

O Christ crucified, present in the poor and suffering, save our souls!

O God, fill our hearts with your Divine Grace and open them to the example set by your servant, Mother Teresa of Calcutta. In your fathomless mercy, grant that the souls of Teresa and Christopher might endlessly rejoice together in eternal beatitude, beholding You face to face, without even an image in between.

http://www.youtube.com/watch?v=xzIPBRnYHQk

Blessed Teresa of Calcutta, friend of the poor, lover of that Heart which exploded with charity on the Cross, please pray for the repose of the soul of Christopher Hitchens, and for the salvation of us sinners on earth.

"The Little Book.." was the first instructional text I read on CoffeeScript, i.e. beyond Coffee's home page hosted on GitHub.

I followed up with the following free e-book, which I highly recommend:

Smooth CoffeeScript

http://autotelicum.github.com/Smooth-CoffeeScript/

Not sure if you'd have any thoughts on this matter...

The JavaScript community as a whole (seen especially in the direction of node.js + NPM) is moving away from global namespaces and toward the "module pattern" and dependency injection (note: I had no idea what those terms really meant 6 months ago).

Presently, Joose3 goes against that grain. For example, if in a node.js script you:

   require('joose')
   if (Joose) { console.log(true) } // prints true!

Basically, the global namespace gets auto-populated with "Joose" and a chain of namespaces below that. This is very Perl/Moose-like, of course.

When you define classes, roles, etc. you get similar behavior:

   Joose.Class('MyClass', {...})
   if (MyClass) { console.log('effectively stubbed in a global namespace!') }
   // does log that text to console, as Joose.Class() behaves that way

And in fact, Joose3 encourages you to embrace that behavior (with `use:` builders and lots of discrete files) to arrive at a network of cross-referenced namespaces which altogether form a library, and API usually.

To go with the flow, and especially to take advantage of emerging module specs like AMD (commonjs thing), a redesigned Joose (i.e. Joose4) needs to eschew global namespaces entirely:

   var myJuice = require('joose')
   ...
   // There should be no tie to a "Joose" namespace as such

But how to do that, and elegantly?

Any wisdom from the Perl community in that regard? Maybe someone else has been trying to port Perl stuff to JavaScript/node.js and has found the perfect formalism for translating from global namespaces -> module pattern + dependency injection? Know any Moose wizards that would be willing to help explore this matter?

No previous Perl programming-experience. I've been consciously aware of Perl since at least 1998 and even poked at the source code of some scripts here and there, but didn't bother to really learn anything about it until recently.

A brief explanation; perhaps someone here will be inspired or is thinking along similar lines:

I've been using an "object system" for JavaScript named Joose: http://joose.it/

Joose is amazing and is, roughly speaking, a port of the Moose object system for Perl to JavaScript. (Moose is mentioned in various comments below and many times in the "Modern Perl" book.)

The principal author/maintainer of Joose v3 (Nickolay Platonov) has developed an ecosystem of tools on top of Joose3 and for Joose-oriented distributions (github.com/SamuraiJack). Much of their design is inspired by popular distributions in Perl's CPAN (Nickolay has a strong background in Perl, obviously). And some of them are still tied into Perl libraries, not simply ports to JavaScript.

As node.js and its package manager NPM have evolved rapidly in the last 12 months, some of the Joose stuff is lagging behind and in need of an overhaul, e.g. Nickolay's "JSAN plugin" for Dist::Zilla.

I've been wanting to help, but it's difficult to hack on Perl code if you don't even know the syntax. Well, that's where chromatic's book has come to the rescue! To be honest, it's been a real eye-opener and, as I suggested earlier, I think this Perl learning-experience is actually going to be a big boon for me in the near term and into the future. It's already allowing me to view Joose and related libraries through new eyes.

Over the past week I've read "Modern Perl", and will finish it later today:

http://onyxneon.com/books/modern_perl/

The ebook/PDF edition is free! It's a great book for learning (modern) Perl basics if you're already familiar with programming concepts and another language like JavaScript (which is where I'm coming from).

Actually, I think the knowledge and best-practices gleaned from the book will help to make me a better programmer in a general sense (not just in terms of the Perl language). It's well written, a pleasure to read and I highly recommend it.

As someone who uses and develops open source software, communication via IRC (especially the Freenode network) is an important element of my day-to-day routine.

I'm very happy running weechat in tmux, on a Linux VPS hosted by Rackspace.

I can then connect via ssh to that VPS and tmux/weechat session from multiple machines. For about 2 years I used irssi, but I dumped it for weechat.

It would be interesting to find out if using Hans Montanus's non-canonical formulation of GR (which involves a Euclidean metric and perfectly flat space-time) would yield the same numerical predictions, just with different "book keeping".

That would put a different spin on the notion of Einstein "being right" as I think a lot of folks subconsciously equate GR with the "strangeness" of the Minkowski metric and non-Euclidean space-time manifold.

Oh, forgot to point out the other big difference. Slicehost had (and still has) a monthly billing model with a monthly bandwidth allowance bundled into the cost. Rackspace Cloud Servers costs are calculated on two factors: how many hours the Cloud Server ran that month (from the day/time you instantiated it); AND then bandwidth usage is calculated separately, based on some $$/GB rate:

http://www.rackspace.com/cloud/cloud_hosting_products/server...

So, the real point is that even if this wasn't apparent to you the customer, the substantial differences between Cloud Servers and Slices was branding and different pricing models; the support teams were also separate (and the two front-line support teams have different "styles"). Otherwise, behind the scenes, they're literally the same thing -- in terms of data centers, hardware platforms and hypervisors, etc., etc.

No, you are incorrect. Slicehost technology is Rackspace Cloud Servers technology. Cloud servers and Slicehost slices are running in the same racks on the same hardware using identical technology stacks -- always have been. The control panel for managing a Rackspace Cloud account and products (including servers) is distinct from the Slicehost customer control panel, and the support teams were distinct groups of people. Now these two corporate structures and logical pools of resources will simply be merged under the name Rackspace Cloud Servers.

The author mentions CPS...

There already exists a powerful cross-environment JavaScript CPS implementation called JooseX.CPS:

https://github.com/SamuraiJack/JooseX-CPS

Tutorials:

http://joose.it/blog/2011/02/14/joosex-cps-tutorial-part-i/

http://joose.it/blog/2011/02/22/joosex-cps-tutorial-part-ii/

If you're not familiar with the Joose object system (works great in browsers and node.js), you should give it a look: http://joose.github.com/Joose/doc/html/Joose.html

Also, CPS is not the only option for dumping callbacks in browsers / node.js. Another would be the Functional Reactive style. See Flapjax: http://www.flapjax-lang.org/

I'm working on a reimplementation of Flapjax right now: https://github.com/michaelsbradleyjr/Jolt

It's got Joose under the hood and I'm generalizing all the library functions for n-ary EventStreams and Behaviors (Reactive concepts). It's very much a work in progress and the test coverage is non-existant atm, but that's owing to the fact I'm working from an existing, working code base. As soon as I have all the core estream and behavior facilities in place, I'm planning to write some exhaustive tests that use JooseX.CPS together with the Joose3 author's Test.Run library: https://github.com/SamuraiJack/test.run

How amazingly cool is this!

http://jsfiddle.net/michaelsbradleyjr/sZUtU/

I had not really tinkered with flapjax on the client-side until tonight, but jsfiddle sparked my instincts to really fiddle with something I had been delaying fiddling (or "tinkering") with.

So, thank you, jsfiddle! I think you're going to make for a powerful creativity enhancer. :-D

jade looks interesting, had not heard of it before and will be looking closely at it for sure.

I'd like to also recommend Nickolay Platonov's little-known but powerful JS templating library "Shotenjin":

https://github.com/SamuraiJack/Shotenjin

Shotenjin is built with Joose v3, which also rocks:

https://github.com/Joose/Joose

I had Office Depot print this cheat sheet: in color, legal-sized, double-sided, laminated with a heavy/stiff plastic and spiral bound. It now sits off to the side of my desk and has made for an invaluable reference over the past year.

My beliefs and meditation-prayer practices are according to the Christian Faith, but "sitting quietly, doing something" is an apt description whether it's Buddhist meditation or Christian mental prayer (a Western form of meditation).

I am happy to share with readers here the most excellent compendium of the Ignatian method of Christian mental prayer that I have ever encountered:

- Fifth Treatise: On the Excellency of Prayer

http://www.holynamesoftware.org/OnPrayer.pdf

The following essay is a real treasure too:

- The Practice of Lectio Divina

https://docs.google.com/Doc?docid=0AdgpYJu8XEUoZGRxc2Z6cWtfM...

Z-pinch!!!

See: http://plasmauniverse.info/downloadsCosmo/KukushkinKartinovC...

Joose is an open source "object system" built with JavaScript on top of JS which allows one to employ classes, modules, roles (like mixins) and a number of other programming concepts found in Ruby, Smalltalk and other popular OO languages. It was inspired Perl's Moose system.

Check it out!

http://joose.it/

current release of ver 3: http://openjsan.org/doc/s/sa/samuraijack/Joose/3.012/lib/Joo...

There's a nice side-by-side comparison of what it looks like to build some classes with and without Joose here:

http://openjsan.org/doc/s/sa/samuraijack/Joose/3.012/lib/Joo...

I'm quite frequently plugging Joose in my comments here on HN, but I don't want to give the impression I'm just reflexively "advertising" for it anytime someone mentions JavaScript. As JS continues to rise in popularity and importance for both client-side (mobile, browser, etc.) and server-side apps, adoption of "power tools" like Joose can help one to avoid "re-inventing the wheel" over and over again.

Something similar is Coglan's JS.Class, which is modeled very closely on Ruby:

http://jsclass.jcoglan.com/

How about Faye? It's an implementation of the Bayeux protocol in JavaScript and Ruby, with both server and client code available in both languages. There's a JS client for browsers too:

http://svn.cometd.com/trunk/bayeux/bayeux.html

http://faye.jcoglan.com/

http://github.com/jcoglan/faye

Check out Joose, which is an object layer built with JavaScript on top of Javascript, amazing stuff!!

http://joose.it/

http://openjsan.org/doc/s/sa/samuraijack/Joose/3.011/lib/Joo...

Nice! I wasn't expecting that, fun surprise :-D

I posted this info as a comment on the guy's blog (still awaiting moderation), but I thought you might find it interesting too, the point being that amazing things are possible with JavaScript and node.js, but if you're thinking single-file scripts with a tangled nest of callbacks and prototypal inheritance chains+constructors that are hard to keep straight, well ... there are better ways ......... :-D

As a JavaScript developer working with node.js (and client side scripts too, of course), I’d like to recommend a couple of related things:

Joose3 — an object system for JavaScript which allows truly classful programming; use it to implement all sorts of meta-programming magic with ease: http://joose.it/ http://openjsan.org/doc/s/sa/samuraijack/Joose/3.011/lib/Joo...

JooseX.CPS — a continuation-passing-style "trait" for Joose classes which helps prevent your asynchronous code from turning into "callback spaghetti": http://joose.it/blog/2010/08/02/asynchronous-aka-non-blockin... http://openjsan.org/doc/s/sa/samuraijack/JooseX/CPS/0.11/lib...

Joose is open source, works with both node.js and in browsers, and there are various ways to install and leverage its libraries, e.g. npm: http://github.com/isaacs/npm

This isn’t an advertisement. I started exploring node.js in early 2010, and my "discovering" Joose was a real boon as I was looking to do some complicated things that seemed daunting when trying to express the concepts in terms of prototypal inheritance.

Not everyone finds it attractive, but I’m always happy to spread the word in hopes that Joose can make someone else’s life and programming projects a little less stressful, which is what it's done for me.

It's pretty clear that this church's site was inciting or had the potential to incite violence.

I think the tricky issue here is "hate speech". There are varying standards, and what metric will/do Rackspace and other hosting providers adhere to?

For example, what if a Rackspace-hosted site contained all or portions of the text of the Catechism of the Catholic Church?

Certainly the Catechism does not promote or incite physical violence. However, it contains unambiguous language regarding the immorality of homosexual acts: http://bit.ly/ccc2357

I'm not attempting to "stir the pot" and initiate an argument over this point in the teaching of the Catholic Church. But I wonder, could/would Rackspace and other hosting companies take down a site which cited this material or posted it verbatim? If not at present, are we headed toward such a day?

In general ...

At what point does a strongly stated religious or moral principle which is at complete odds with the beliefs or lifestyle of another person or group constitute hate speech? And who decides that with respect to something like web hosting, as opposed to someone preaching on a street corner out in public?

Please, no flames, I think this is a serious topic that deserves sincere and balanced treatment.

tmux is a great BSD-licensed alternative:

http://tmux.sourceforge.net/

I've tried both, and the licensing issue aside, I've found I prefer tmux.

Anyway, not wanting to turn this into a gnu vs. bsd, tmux vs. screen argument, but I didn't eve know tmux existed until someone pointed me to it, so I'm just passing on the knowledge.

Ordered on Amazon! Really, I feel very excited, just wanted to say thank you again. I had not stumbled across this resource when googling around for such an intro/guide, or maybe it just didn't catch my eye.

Perfect! Thanks a bunch.

Does anyone know of an "online shell" and tutorial combo that would give a similar kind of learning experience for understanding how computers work at the lower levels, as mentioned at the end of the article:

"The day of study had begun with what must be the ultimate hands-on technology experience: Mr Abrams got the students to be a computer.

They each took on the role of a different part of the machine - CPU, accumulator, RAM and program counter - and simulated the passage of instructions through the hardware.

The five shuffled data around, wrote it to memory, carried out computations and inserted them into the right places in the store."

Through self-study of CS texts and good code that others have written I've been gaining a lot more depth to my OOP programming skills.

I'd love though to get a more ground up, "live action" education on what's happening at the machine level, albeit it would probably need to be based on the simulation of a tiny computer by modern standards, maybe something like Knuth's MixMaster.

Joose has a Modules facility that works pretty nicely both in the browser and in other contexts, e.g. Node.js. When combined with the "use" facility of JooseX.Namespace.Depended, I think you get a similar functionality as to what's being described:

http://openjsan.org/doc/s/sa/samuraijack/Joose/3.010/lib/Joo...

http://openjsan.org/doc/s/sa/samuraijack/JooseX/Namespace/De...

I like OmniFocus for iPhone, and find it to be the perfect companion to OmniFocus running on my laptop:

http://www.omnigroup.com/products/omnifocus_for_iphone/

Let's toss a little theology into the mix: http://oce.catholic.com/index.php?title=Creation