Viser arkivet for stikkord metaprogrammering

3 ålreite Ruby-bøker

Jeg har lest et par bøker i det siste for å friske opp/skjerpe rubyen
min.

Ruby Best Practices

Denne føles som den er rettet mot “avanserte nybegynnere”: de som har
lært det mest grunnleggende via f.eks Pickaxe og ønsker å bli mer
“ruby-ish”. Temaer den går gjennom: basic TDD i Ruby (og generelle råd
til unit testing), API-design med bruk av Rubys metode-argumenter og blokker, litt
dynamisk/metaprogrammering, tekst/fil-håndtering, funksjonell
programmering, debugging, prosjekt/gem-organsiering, samt å støtte både 1.8.x/1.9.x plus litt om standard lib/apier som man kanskje
ikke er klar over at Ruby shipper med.

Eloquent Ruby

Denne har en del overlapp med boka over: også denne er en “god bok nr
to” og satser på å lærer bort idiomatisk Ruby. Den tar for seg basic
kodekonvensjoner, kontroll strukturer, Collections/Enumerable,
String-APIene, regex, symboler, basic OO, tests/specs,
klasser/moduler/blokker, metaprogrammering. Avslutter med prosjekt/gem
struktur og en liten overview av implementasjoner/VM-er (Rubinius,
JRuby etc)

Jeg synes dette er en bedre bok enn Ruby Best Practices fordi den
føles mer velskrevet (kortere, mer fokuserte kapitler, litt som gode
Ruby-metoder? :). Og den har en sterkere avslutning ved at den samler
en del tråder ved å vise hvordan man praktisk kan skrive interne og
eksterne DSLer i Ruby.

Metaprogramming Ruby

Denne boka er mer fokusert enn de to andre. Der de andre bøkene
skraper på overflaten med metaprogrammering (hooks, method_missing,
dynamisk dispatch/metode-opprettelse) så går denne mer i dybden ved å
grundig fortelle hvordan Rubys objekt-system etc fungerer bak
kulissene. Dvs ikke bare hvordan man får til bra ting, men hvorfor
de fungerer. Jeg syntes den var velskrevet og “terse”. Kommer
definitivt til å vende tilbake til denne senere siden jeg ikke har
OO-systemet til Ruby i fingerspissene (og hadde litt dårlig tid da jeg
leste den).

TL;DR:

Ruby Best Practices og Eloquent Ruby fungerer begge bra som “bok nr to
etter Pickaxe”, men de har en del overlapp. Velg Eloquent Ruby siden
den er mer velskrevet. Metaprogramming Ruby er en flott bok hvis man
vil lære mer om hvordan Ruby funker bak kulissene.

MtnWest RubyConf: Kodegenerering

Skal prøve å kondensere informasjonen litt, men fortsatt prøve å beholde litt innhold! Nå har jeg vært uten nettverk i 5 timer, ikke så lett med internett, med et accesspoint, og over 200 deltakere!

Etter lunsj snakket Giles Bowkett om kodegenerering ved hjelp av magisk metaprogrammering (with safety scissors)

Når man snakker om metaprogrammering i Ruby, snakker man oftest om meta-oo. Man kan gjøre dette på flere måter, og en vanlig måte er å aliase gamle metoder, og omdefinere dem – noe som ofte kalles monkeypatching – og anses som dårlig praksis av mange. De som har fulgt litt med har fått med seg mye motstand mot monkeypatching i blogospheren. Grunnen er hovedsaklig endrene biblioteker som monkeypatches, og det da blir vanskelig å spore endringene.

Giles mener en av de store styrkene til Ruby er at det essensielt tilgjengeliggjør avansert programmering som higher order programmering kjent fra funksjonelle språk som Lisp; på en enkel og forståelig måte! Innenfor metaprogrammering advokerer han hovedsaklig to paradigmer – om jeg kan kalle det det 1) kodegenerering og 2) monkeypatchet monkeypatching.

Angående kodegenerering snakker han hovedsaklig om hvordan man kan bruke Ruby til å skape annen programmeringskode, for eksempel bruke ruby2ruby biblioteket til å generere kode:

irb> l = lambda { puts “i lambdaen” }
=> #<Proc:0×0137ebf4@(irb):13>
irb> l.to_ruby
=> “proc {\n puts(”i lambdaen")\n}"

Eller:

irb> class BlaBla; def name; “bla?”; end; end
irb> puts Ruby2Ruby.translate(BlaBla)
class BlaBla < Object
def name
“bla?”
end
end

Det andre og kanskje mer interessante caset er ideellt for bruk med Rubinius. Der kan man nemlig leke med alt på en ganske sikker måte, noe som åpner opp for veldig kul bruk av monkeypatching. Et eksempel er at man kan overskrive Class.new for å tracke annen monkeypatching:

class Class
alias :old_new, :new
def new(param)
puts “created #{self.name}”
old_new(param)
end
end

Dette vil fungere i Rubinius der alt er Ruby, men er ganske usikkert i andre implementasjoner der store deler er skrevet i C, Java, .NET, osv. Denne ideen kan utvides kraftig, slik at man for eksempel kan bruke det til sporing av monkeypatching, eller istedenfor å bare skrive strenger, kan man for eksempel skrive kode (“#{self.name.camelize}.new(#{param})”), eller rett og slett skape objekter med metaprogrammering av koden.

Veldig interessant ide!