eigenclass

I admit I perhaps haven't looked into this as much as I perhaps should have before making that claim. My understanding is that the rubyspec project (http://rubyspec.org/), is an effort to retrospectively document all the stuff the language does. Compare ruby: http://eigenclass.org/hiki.rb?Changes+in+Ruby+1.9, to python: http://docs.python.org/dev/whatsnew/2.7.html I appreciate this isn't a great example, as python 2.7 isn't a different implementation (ruby 1.8 -> 1.9 is though), but this has been my experience of the way things are documented language-wise.

I recommend http://eigenclass.org/hiki/rocaml

In the same vein: Gibak. http://eigenclass.org/hiki/gibak-backup-system-introduction http://eigenclass.org/hiki/gibak-0.3.0 https://github.com/pangloss/gibak for an improved fork (last commit in 2008, but still...)

I assume you are using git to manage your home directory. I use gibak[1] for the same(built on top of git). Out of curiosity, what is your setup like? [1] http://eigenclass.org/hiki/gibak-backup-system-introduction

The part I find particularly silly is where he writes: For example, assume that the hash table implementation shrinks the table if the number of full buckets drops below half, and grows the table if it becomes over full. If the table starts out with 100 buckets, and the number of buckets falls to 49, the size is shrunk to 50. I've never seen a hashtable that actually works this way. It's common knowledge that performance of hashtables degrades long before the "full" point. (I particularly like the explanation of that here: http://eigenclass.org/R2/writings/separate-chaining-vs-double-hashing)

See also Gibak by Mauricio Fernandez http://eigenclass.org/hiki/gibak-backup-system-introduction http://eigenclass.org/hiki/gibak-0.3.0

This is also why things like the double-inclusion problem are still live issues. http://eigenclass.org/hiki/The+double+inclusion+problem One problem that Ruby does need to deal with is when implementation problems become institutionalised as language specifications. http://blog.jcoglan.com/2009/06/06/when-bugs-become-features/

Sites I like from my feeds, aiming for variety: * Joseph Miklojcik (emacs, lisp, languages) http://jfm3-repl.blogspot.com/ * Mauricio Fernández (functional, with ocaml focus) http://eigenclass.org/R2/ * Colin Percival (tarsnap, freebsd security) http://www.daemonology.net/blog/ * Matthew Garrett (mobile linux, power management) http://mjg59.livejournal.com * Brad Fitzpatrick (memcached, pubhubsubbub) http://advogato.org/person/bradfitz/diary.html * Chris Neukirchen's Trivium (all links, great jumping point) http://chneukirchen.org/trivium/

There's a toy prolog interpretter written in Ruby as well (http://eigenclass.org/hiki.rb?tiny+prolog+in+ruby). What I'd really like to see is a Ruby interpretter written in Scheme - or Forth or Erlang or one of those other cool languages...

ruby 1.9.1 is mainly stability fixes to ruby 1.9, which had a few .. quirks. for a less-than-complete guide to ruby 1.9 features, consider reading eigenclass's summary from way back: http://eigenclass.org/hiki.rb?Changes+in+Ruby+1.9

Ruby 2.0 is a not a "start from scratch" project. It's an evolution of the language (which will be done mostly in the experimental 1.9 releases) with a new interpreter. Once 1.9 is stable it will turn into the 2.0 release. The actual effect on Ruby users will be noticeable, but minimal. See http://eigenclass.org/hiki/Changes+in+Ruby+1.9 for some of the changes that are coming up.

The very latest possible date real development started on Ruby was Aug 19, 1994. http://cvs.ruby-lang.org/pub/ruby/1.0/ChangeLog-pre-alpha It is likely this code predates that date given that there is no reference to the 0.95 release or anything before that. update: the earliest release I can find is Ruby 0.49 from http://eigenclass.org/hiki/ruby+0.95 (direct link: ftp://ftp.ruby-lang.org/pub/ruby/1.0/ruby-0.49.tar.gz) The earliest date mentioned in the CVS entries file is March 17, 1994. To me, the point of this whole thing is that the author's statement of "Ruby is a newer...language" is inaccurate. You're absolutely correct that I cannot definitely prove that "development on PHP started a year after Ruby." And language age comparisons are entirely meaningful in this case, given that the OA specifically describes Ruby as a newer language than PHP. Ruby is definitely clearer and cleaner. But it is certainly not newer.

In the beginning, there was machine code. this is essentially inputting what the computer actually executed, without any translation or compilation ( http://en.wikipedia.org/wiki/First-generation_programming_language ) Then there was assembler/assembly. This is similar to the aforementioned, except easier to read. Assembly is a 1:1 mapping between symbols and their machine-understandable counterparts. This is the first step in the abstracting of programming code from executable code ( http://en.wikipedia.org/wiki/Second-generation_programming_language ) Then, there are so-called 3GL. These let you do fancy things like having named variables, symbolic manipulation, function calls, abstract (arbitrary) syntax. This encompasses many of the languages people use at work today (c/c++/java) ( http://en.wikipedia.org/wiki/Third-generation_programming_language ) It is important to note that the purpose of 3GL, like assembly before it, was to create a separation between what the programmer typed and what the machine ran. The latter being derived from the former according to its rules. ( http://en.wikipedia.org/wiki/Fourth-generation_programming_language ) 4GL are the next step along this line. The focus of 4GL is to make it that the code entered is as focused on the domain logic as possible, hiding the implementation details. The phrase "further from the machine and closer to the domain"in the wikipedia 4GL page sums it up nicely. To a chip designer, machine code is a high level…

The code has grown and become more complex in the last versions because I optimized it until directory traversal + glob matching got sensibly faster than Git's own (git-ls-files --exclude-standard doesn't do exactly the same thing as find-git-files, but meaningful performance comparisons can be done with the -d -o and -m -o options). It's still much smaller than metastore (1/3rd or so) even though it does much more now, however. You can take a look at the initial version of ometastore here: http://eigenclass.org/repos/gitweb?p=gibak.git;a=blob;f=ometastore.ml;… The functionality from metastore takes ~270 lines vs. ~1500 lines of C, the support for .gitignore takes another 70locs. It's got one or two bugs in the Gitignore support which I fixed later (and a silly bug in do_finally), but this code is simpler if you want to see what OCaml looks like in actual use (for a system tool, in this case). It's almost (if not actually, I don't remember) the "first version that typed", by the way.

ruby: http://eigenclass.org/hiki/rcodetools http://railroad.rubyforge.org/ http://www.pathf.com/blogs/2008/12/read-the-source-luke-a-readers-guid… http://stackoverflow.com/questions/37105/how-do-you-actually-read-sour… --------------------------- (you'll see lots of questions on stackoverflow: navigate/inspect/read source repo's) http://stackoverflow.com/questions/1623906/programmatically-inspect-ne… http://stackoverflow.com/questions/935516/how-does-macos-developer-nav… python: http://code.activestate.com/recipes/213898/ http://stackoverflow.com/questions/1568544/given-a-python-class-how-ca… emacs, vim, ctags, etags, http://stackoverflow.com/questions/1220456/navigating-effectively-thro…