roebe 0.5.122

data/lib/roebe/documentation/misc.rb

@@ -0,0 +1,1353 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+module Roebe::Documentation
+
+  # ========================================================================= #
+  # === Roebe::Documentation.misc
+  # ========================================================================= #
+  def self.misc
+    div {
+      img('PROGRAMMING_LANGUAGES/RUBY/RUBY.png','FLL')+
+      img('PROGRAMMING_LANGUAGES/RUBY/RUBY_HYDRA.png',
+          'bblack0 mart0_5em','drag_hydra',
+          'margin-left:10%;')
+    }+
+    div(css_class: 'outer_div') {
+    div(css_class: 'default', id: __method__.to_s) {
+      h2(__method__)+
+      br+
+      # ===================================================================== #
+      # === Count frequency of a word
+      # ===================================================================== #
+      div {
+        frage("Wie zähle ich die frequency eines Wortes? (word count, word
+        frequencies)")+
+        cmd('  freq = Hash.new(0)')+
+        cmd('  open("/home/x/DATA/RPG/RPG.php").read.scan(/\w+/){ |wort| freq[wort] += 1 }')+
+        cmd('  freq.sort.each { |wort, zahl| puts "#{wort} - #{zahl}" }')+
+        br+
+        e('oder etwas kürzer:')+
+        br+
+        cmd('  freq = Hash.new(0)')+
+        cmd('  file = "kaiser.rb"')+
+        br+
+        cmd('  open(file).read.scan(/\w+/) { |wort| freq[wort] += 1 }')+
+        cmd('  freq.sort.each { |wort, zahl| puts "#{wort} - #{zahl}" }')
+      }+
+      frage('What is a container?')+
+      cmd('Containers are <b>objects</b> that hold references to one or
+      more other objects.')+
+      br+
+      e('Das verwendet man, da manche Terminals kleine Datenmenge
+      abpuffern und nicht aussenden.')+
+      br+
+      e('Das "flushing" sendet die Datenmenge auf einmal raus und
+      mit <b>.sync = true</b> wird dies erzwungen.')+
+      br+
+      e('Über Commandline Optionen geht dies so:')+
+      br+
+      cmd('  ruby -e "STDOUT.sync = true"')+
+      br+
+      e('Dies erstellt ein Objekt der Klasse UnboundMethod.')+
+      br+
+      cmd('  x = Array.instance_method("pop") # => #<UnboundMethod: Array#pop>')+
+      cmd('  string = String.instance_method(:size) # => #<UnboundMethod: String#size>')+
+      br+
+      frage('Wie erhalte ich eine <b>Referenz</b> zu define_method?')+
+      cmd('D = Object.method(:define_method)')+
+      br+
+      frage('Ist es möglich <b>protected attr_accessor</b> zu verwenden?')+
+      e('Ja.')+
+      br+
+      cmd('  attr_accessor :foo; protected :foo, :foo=')+
+      br+
+      frage('Was sind die grundlegenden Typen (Types) in Ruby?')+
+      e('Numbers, strings, arrays, hashes, ranges, symbols, regular
+      expressions.')+
+      br+
+      # ===================================================================== #
+      # === Wie verwenden wir .instance_exec() in Ruby?
+      # ===================================================================== #
+      frage('Wie verwenden wir .instance_exec() in ruby?')+
+      e('Ruby 1.9 hat die Methode <b>instance_exec()</b> hinzugefügt.')+
+      br+
+      e('Diese funktioniert ähnlich wie instance_eval(), aber sie
+      erlaubt einem auch, Argumente an einen Block zu übergeben:')+
+      br+
+      cmd('  class C')+
+      cmd2('    def initialize')+
+      cmd3('      @x, @y = 1, 2')+
+      cmd2('    end')+
+      cmd('  end')+
+      br+
+      cmd('  C.new.instance_exec(3) {|arg| (@x + @y) * arg }')+
+      cmd('  # => 9')+
+      br+
+      anm('An dieser Stelle sei noch ein Unterschied zwischen
+      <b>instance_eval</b> und <b>class_eval</b> bemerkt:')+
+      br+
+      lem('class_eval definiert instance_methods da man sich im
+      Körper einer Klasse befindet.')+
+      br+
+      lem('instance_eval agiert als ob man innerhalb von self
+      Methoden definieren würde, also erhält man damit class
+      methods.')+
+      br+
+      e('Beispiel für .instance_eval:')+
+      br+
+      cmd('class Foo; end')+
+      br+
+      cmd('Foo.instance_eval {
+        def test
+          puts "this is a test"
+        end
+      }')+
+      cmd('Foo.test')+
+      br+
+      anm('Man kann mittels .instance_eval auch Konstanten definieren:')+
+      br+
+      cmd('  module Foo; end; Foo.instance_eval { self::BAR = :b }')+
+      br+
+      e('Es gibt seit Ruby 1.9 eine weitere Methode wie man das ganze
+      machen kann:')+
+      br+
+      e('Mittels .instance_exec.')+
+      br+
+      cmd('animal = "cats"')+
+      cmd('"dogs".instance_exec(animal) {|other|
+        puts "#{other} and #{self}" 
+      }')+
+      cmd('  pp object.instance_methods')+
+      br+
+      e('.instance_methods akzeptiert ein (optionales) Argument, true
+      oder false. Default ist true. Wenn das Argument false ist, dann
+      geben wir nur all jene instance_methods wieder die wir selbst
+      definiert hatten - also nicht jene, die wir von der Mutterklasse
+      erhalten haben.')+
+      br+
+      cmd('  object.class.instance_methods(false)')+
+      br+
+      e('Noch ein Beispiel, unter Verwendung von
+      .public_methods:')+
+      br+
+      cmd('  class Foo; def test1; end; def test2; end; end; 
+      Foo.new.public_methods(false) # => [:test1, :test2]')+
+      br+
+      e('Ist alias wunderbar?')+
+      br+
+      e('Nun - es hat eine Einschränkung. Es funktioniert nur zu
+      instance_methods. Das heisst das man class << self
+      verwenden muss um ein Alias auf eine class Method
+      zu erreichen.')+
+      br+
+      frage('Wie seeke und schreibe ich in einer Datei?')+
+      e('Das geht mittels <b>r+b</b>.')+
+      br+
+      cmd("  File.open('test.txt','wb'){|f| f.print 'A' * 1024 }")+
+      cmd("  File.open('test.txt','r+b'){|f| f.seek(512); f.print 'BBBB' }")+
+      br+
+      frage('Wo ist das <b>SITELIBDIR</b> von Ruby zu finden?')+
+      cmd("  RbConfig::CONFIG['sitelibdir'] => '/Programs/Ruby/2.6.3/lib/ruby/site_ruby/2.6.0'")+
+      br+
+      frage('Wie lese ich eine Datei in Ruby mit expliziter Angabe des
+      encodings ein?')+
+      cmd("  this_file =
+      '/home/x/DATA/PC/PROGRAMMING_LANGUAGES/RUBY/documentation/ruby_errorcodes.cgi'")+
+      cmd("  File.read(this_file, :encoding => 'iso8859-1')")+
+      br+
+      cmd('  a = "abc".force_encoding("UTF-8")')+
+      cmd("  string.force_encoding('UTF-8')")+
+      cmd('  b = "def\xff".force_encoding("ISO-8859-1")')+
+      br+
+      e('Ein interessanter Weg zum Öffnen einer Datei ist folgender:')+
+      br+
+      cmd('  File.read("chinese.txt", :encoding => "UTF-8")')+
+      cmd('  File.binread("foo.jpg")')+
+      br+
+      anm('Man sollte mit den Encoding-Problemen aufpassen, es kann sonst 
+      zu Problemen führen wie: <b>invalid multibyte char (US-ASCII)</b>')+
+      br+
+      frage('Wie erhalte ich den Class Name einer Klasse?')+
+      e('Dies geht entweder so:')+
+      br+
+      cmd("  foo.class.name.split('::').last")+
+      br+
+      e('Oder mittels Yard über .class_name.')+
+      br+
+      cmd('  module Hello; class Baby; end; end Hello::Baby.class_name # => "Baby"')+
+      br+   
+      frage('Wie setze ich Default Werte?')+
+      e('Am elegantesten geht dies wohl wie folgt:')+
+      br+
+      cmd('  def name; @name ||= "This is the default value for the
+      variable @name"; end')+
+      br+
+      # ===================================================================== #
+      # === arity
+      # ===================================================================== #
+      div('','arity') {
+        h2('Arity')+
+        frage('Wie finde ich heraus, wie viele Argumente eine 
+        Methode akzeptiert?')+
+        e('Dies geschieht mittels der <b>.arity</b> Methode.')+
+        br+
+        e('Beispiele:')+
+        br+
+        cmd('  "sss".method(:concat).arity # => 1')+
+        cmd('  method(:method_name).arity')+
+        cmd('  instance_method(:method_name).arity')+
+        br
+      }+
+      # ===================================================================== #
+      # === Wie pingen wir in ruby?
+      # ===================================================================== #
+      frage('Wie pingen wir in Ruby?')+
+      cmd('  Ping.pingecho "google.com", <timeout>, <port>')+
+      cmd('  Ping.pingecho "google.com", 1 # => false')+
+      br+
+      e('Wobei <b>timeout</b> die Anzahl an Sekunden ist die man für
+      eine Antwort warten soll (defaults to 5) and port is the port
+      to use (defaults to the <i>echo</i> port)')+
+      br+
+      frage("Wie schalte ich das Buffern von Strings aus? (disable String
+      Buffering, disable buffering)",'stdout')+
+      cmd('  $stdout.sync = true','buffering')+ # rf rubydocu buffering
+      cmd('  $stderr.sync = true')+
+      br+
+      e('Dies stellt sicher das die Ausgabe auf den Bildschirm
+      sofort erscheint, ohne Verzögerung.')+
+      anm('Man darf nicht zu $stdout assignen. Will man dies dennoch
+      tun, so muss man <b>$stdout.reopen</b> verwenden.')+
+      br+ 
+      frage('Wie kopiere ich rekursiv ein Verzeichnis in ruby?')+
+      cmd('  FileUtils.cp_r( source + "/.", dest )')+
+      cmd('  FileUtils.cp_r( "/Depot/jjj/hpricot-0.8.4/.", "/Depot/jj")')+
+      cmd("  FileUtils.cp_r('./dir1', './to_dir', { :verbose=>true, :noop=>true })")+
+      cmd('  FileUtils.cp_r( "/Depot/jjj/hpricot-0.8.4/.", "/Depot/jj", { :verbose=>true, :noop=>true })')+
+      br+
+      a('http://www.ruby-doc.org/core/classes/File.html#M000008',
+        content: 'DEF')+
+      br+
+      frage('Was meinen wir mit den Attributen eines Objekts, in ruby?')+
+      e('Dies sind die <b>external sichtbaren Facetten</b> eines Objekts.')+
+      br+
+      frage('Wie finde ich möglichst viel über die <b>Plattform</b> raus,
+      auf der Ruby rennt?')+
+      cmd("  require 'mkmf'")+
+      cmd('  pp CONFIG')+
+      br+
+      frage('Wie kodieren wir einen String in ruby, in einem bestimmten
+      Encoding?')+
+      cmd('  puts "äöü".encode("iso-8859-1")')+
+      br+
+      frage('Wie kopiere ich eine Datei in ruby? (copy tag, copy_file tag)','copy')+
+      cmd('  FileUtils.cp(from, to)')+
+      br+
+      frage('Wie finden wir heraus, ob xyz eine Datei ist? (is file, is file?, is_file?)')+
+      cmd('  File.file?(xyz)')+
+      cmd('  File.file? file')+
+      br+
+      frage('Wie finden wir den Namen eines Anwenders heraus wenn ich
+      seine UID habe?')+
+      cmd(' Etc.getpwuid(0)')+
+      br+
+      frage('Was sind <b>Hooks</b> in ruby?')+
+      e('Hooks sind bestimmte Methoden die Ruby automatisch aufruft.')+
+      br+
+      e('Wenn eine Klasse eine Class Method namens <b>.inherited</b> 
+      definiert so ruft Ruby diese auf wann immer die Klasse subclassed
+      wird.')+
+      br+
+      cmd('  def self.inherited(i)')+
+      cmd2('    @array << i')+
+      cmd('  end')+
+      br+
+      frage('Wie verwenden wir quantity, in ruby?')+
+      cmd("  require 'quantity/all'")+
+      br+
+      cmd('  1.meter                                              # => 1 meter')+
+      cmd("  1.meter.to_feet                                      # => 3.28083... foot")+
+      cmd("  c = 299792458.meters / 1.second                      # => 299792458 meter/second")+
+      cmd("  newton = 1.meter * 1.kilogram / 1.second ** 2        # => 1 meter*kilogram/second^2")+
+      cmd("  newton.to_feet                                       # => 3.28083989501312 foot*kilogram/second^2")+
+      cmd("  newton.convert(:feet)                                # => 3.28083989501312 foot*kilogram/second^2")+
+      cmd("  jerk_newton = newton / 1.second                      # => 1 meter*kilogram/second^3")+
+      cmd("  jerk_newton * 1.second == newton                     # => true")+
+      cmd("  mmcubed = 1.mm.cubed                                 # => 1 millimeter^3")+
+      cmd("  mmcubed * 1000 == 1.milliliter                       # => true")+
+      cmd("  [1.meter, 1.foot, 1.inch].sort                       # => [1 inch, 1 foot, 1 meter]")+
+      cmd("  m_to_f = Quantity::Unit.for(:meter).convert_proc(:feet)")+
+      cmd("  m_to_f.call(1)                                       # => 3.28083... (or a Rational)")+
+      br+
+      frage('Wie verwenden wir <b>defined?</b>, in ruby?')+
+      e('defined? ist ein merkwürdiges Keyword das einem nil zurückgibt
+      wenn das Argument unbekannt ist. Ansonsten gibt es einem den
+      Wert wieder.')+
+      br+
+      e('Beispiele zu <b>defined?</b>:')+
+      br+
+      cmd('  defined? some_method # => nil')+
+      cmd('  def test; end; defined? test # => "method"')+
+      cmd('  super if defined? super')+
+      br+
+      frage('Wie erhalten wir eine bestimmte instance variable in ruby?',
+      'get_instance_variable')+ # get ivar tag.
+      e('Mittels instance_variable_get.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd("  object.instance_variable_get '@foo'")+
+      cmd("  self.instance_variable_get '@foo'")+
+      br+
+      e('Mittels instance_variable_set setzt man eine Variable
+      (set ivar, ivar set):')+
+      br+
+      cmd("  object.instance_variable_set")+
+      br+
+      cmd('  object.instance_variable_set(symbol, object) => object')+
+      cmd("  object.instance_variable_set(:@a, 'dog') # => 'dog'")+
+      cmd("  object.instance_variable_set(:@c, 'cat') # => @c is now = 'cat'")+
+      br+
+      e("Mittels <b>.instance_variable_set()</b> setzen wir die Instance
+      Variable in Form eines Symbols zu einem Objekt. Dies umgeht aber
+      Encapsulation und mag nicht im Sinne des Entwicklers, der den Code
+      schrieb, sein.")+
+      br+
+      e('- Ein Block kann selbst ein block argument übernehmen in Ruby 1.9:')+
+      br+
+      l2em('|arg1,arg2,&block|')+
+      br+
+      e('.chr akzeptiert seit 1.9 auch Encoding:')+
+      br+
+      cmd('  322.chr("UTF-8") # => "kann man nicht darstellen hier aber es is 
+      so eine Art I mit schrägem Strich durch"')+
+      br+
+      # ===================================================================== #
+      # === Können wir mehrere BEGIN und END Blöcke in einer .rb Datei
+      #     verwenden?
+      # ===================================================================== # 
+      frage('Können wir mehrere BEGIN und END Blöcke in einer .rb Datei
+      verwenden?')+
+      e('Ja. BEGIN wird sequenziell abgearbeitet, END wird
+      umgekehrt-sequenziell abgearbeitet.')+
+      br+
+      e('Ruby definiert die globals <b>false</b> und <b>nil</b>.
+      Das sind die einzigen beiden Werte die als "false"
+      interpretiert werden.')+
+      br+
+      # ===================================================================== #
+      # === Wie sehen wir alle Methoden eines Objekts an?
+      # ===================================================================== #
+      e('Wie sehen wir alle Methoden eines Objekts ein?')+
+      cmd('  object.public_methods(false)')+
+      br+
+      frage('Wie kann ich den Namen der aktuellen Methode herausfinden?
+      Wie finde ich den Namen einer Methode heraus?')+
+      e('Dies geht mittels <b>Kernel.__method__</b>')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('def foo')+
+      cmd2('  puts __method__')+
+      cmd('end')+
+      br+
+      anm('__method__ gibt ein <b>Symbol</b> zurück.')+
+      br+
+      frage('Wie lese ich den MBR?','mbr')+ # mbr tag
+      cmd('  File.open("/dev/sda") {|f| f.read(512) }')+
+      br+
+      frage('Wie finde ich heraus wo eine Methode definiert ist?')+
+      e('Mittels <b>.source_location</b>')+
+      br+
+      e('Man kann <b>.source_location</b> auf jede Methode in Ruby 1.9
+      anwenden.')+
+      br+
+      e('Beispiele:')+
+      br+
+      cmd('  internal_method = "cat".method(:upcase)')+
+      cmd('  internal_method.source_location # => nil')+
+      cmd('  class A; def foo; end; end; file, line = A.instance_method(:foo).source_location')+
+      br+
+      frage('Wie generiere ich ein zufälliges Passwort - der beantworte
+      eine Frage zufällig mit yes oder no?')+
+      cmd('  password = (1..8).map { chars[rand(chars.size)] }.pack("C*")')+
+      br+
+      e('The answer is')+
+      br+
+      cmd('  %w(no yes).rand')+
+      br+
+      frage('Wie lesen wir einzelne Chars in ruby ein?')+
+      e('Verwende hierzu io-console von http://www.rubyist.net/~nobu/ruby/')+
+      br+
+      a('http://www.rubyist.net/~nobu/ruby/io-console.tar.bz2',
+        content:'Io Console')+
+      br+
+      cmd("  require 'io/console.so'")+
+      br+
+      cmd('  print STDIN.getch')+
+      br+
+      frage('Wie bekomme ich die Zeile des Fehlers?')+
+      cmd('  puts "Failed to load in #{__FILE__}:#{__LINE__}"')+
+      br+
+      frage('Wie prüfe ich ob eine Methode definiert ist? Wie überprüfe ich 
+      konditional ob sie existiert? (defined method, has method, 
+      has method?)','method_defined')+
+      br+
+      e('Dies geht entweder mittels <b>method_defined?</b> oder mittels
+      <b>respond_to?</b>.')+
+      br+
+      cmd('  method_defined?')+
+      cmd('  unless method_defined? :your_method')+
+      cmd('  Array.method_defined?("size") # => true')+
+      cmd('  Array.method_defined?(:bsearch)')+
+      cmd('  if !method_defined? :to_time')+
+      br+
+      e('Der Vorteil ist das man hier Methoden konditional hinzufügen
+      kann.')+
+      br+
+      e('Noch ein Beispiel hierzu:')+
+      br+
+      cmd('  class Foo;def test;end;end')+
+      cmd('  Foo.method_defined? :test # => true')+
+      br+
+      frage('Wie verwenden wir Symbol#to_proc?')+
+      e('Nun... & ist ein Alias zu to_proc. & calls #to_proc')+
+      br+
+      frage('Wie können wir eine Singleton Method in Ruby definieren?')+
+      e('Da gibt es mindestens zwei Möglichkeiten:')+
+      br+
+      cmd("  c = 'cat'; c.define_singleton_method(:hi) { p 'hi' }")+
+      cmd("  c = 'cat'; def c.hi; p 'hi'; end;")+
+      br+
+      frage('Wie erhalte ich alle Argumente, die eine Methode in
+      Ruby benötigt?')+
+      cmd('  A.instance_method(:method1).parameters # => [[:req, :tuti], [:req, :fruity]]')+
+      cmd('  module Foo; def method1(tuti, frutti); end; end')+
+      br+
+      cmd('  Foo.instance_method(:method1).parameters.map(&:last).map(&:to_s)
+      # => ["tuti", "frutti"]')+
+      br+
+      frage('Wie wird der <b>stack trace</b> normalerweise produziert?')+
+      e('Mittels der <b>Kernel.caller</b> Methode.')+
+      br  +
+      frage('Wie konvertiere ich einen <b>HEXSTRING</b>?')+
+      cmd('  "FF00FF".scan(/../).map(&:hex).map(&:chr).join ')+
+      br+
+      frage('Wie laden wir Dateien die relativ zu anderen
+      Dateien sind, in ruby?','expand_path')+ # relative requires.
+      cmd('  require File.join(File.dirname(__FILE__), "foo", "bar")')+
+      cmd('  require File.expand_path(File.join(File.dirname(__FILE__), "foo", "bar"))')+
+      anm('File.expand_path berücksichtigt Input von ~ der korrekt 
+      zum HOME Verzeichnis konvertiert wird.')+
+      br+
+      e('File.expand_path gibt den absoluten Pfad wieder.')+
+      br+
+      e('__FILE__ ist der Pfad zu der Datei.')+
+      br+
+      frage('Wie können wir in Ruby einen Datensatz gruppieren?
+      (group by first letter)')+
+      cmd('  birds = ["Golden Eagle", "Gyrfalcon", "American Robin", 
+      "Mountain BlueBird", "Mountain-Hawk Eagle"]')+
+      cmd('  grouped_by_first_letter = birds.group_by { |s| s[0] }')+
+      br+
+      e('Wie finden wir heraus ob eine Instance Variable definiert
+      wurde?')+ # is instance variable defined.
+      cmd('  if self.instance_variable_defined? "@foo"')+
+      cmd('  object.instance_variable_defined?("@foo") # => true')+
+      cmd('  object.instance_variable_defined? "@var" # => true')+
+      br+
+      frage('Und wie entferne ich eine instance variable wieder?')+
+      e('Mittels remove_instance_variable. Beispiel:')+
+      br+
+      cmd('  remove_instance_variable(:@foo)')+
+      br+
+      anm('Man kann auch konditional überprüfen ob eine Methode
+      in dem übergeordnetem Objekt existiert:')+
+      br+
+      cmd('  if defined?(super)')+
+      cmd('  super if defined?(super)')+
+      anm('super ist übrigens das selbe wie super(*args, &block)')+ 
+      anm('super(&nil) # Hier wird kein Block übergeben. (only way to
+      suppress passing on a block)')+
+      br+
+      frage('Was ist SCRIPT_LINES__?')+
+      cmd('SCRIPT_LINES__ (Hash)')+
+      br+
+      e('If a constant SCRIPT_LINES__ is defined and references a Hash
+      at the time Ruby is compiling code, Ruby will store an entry
+      containing the contents of each file it parses, with the
+      filename as the key and an array of strings as the value.')+
+      br+
+      e('See Kernel.require for an example, and then over
+      in Kernel.require:')+
+      br+
+      e('The SCRIPT_LINES__ constant can be used to capture the 
+      source of code read using require.')+
+      br+
+      frage('Verwendet Ruby heredoc? (heredoc tag)')+
+      e('Ja. Alles das zwischen TOKEN ist wird gedruckt.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('print << X')+
+      cmd2('  kl')+
+      cmd2('  gegekl')+
+      cmd2('  kl')+
+      cmd2('  kl')+
+      br+
+      e('X','indianred')+
+      br+
+      e('Übrigens - wenn man ein Minuszeichen nach den beiden < setzt 
+      dann kann man den folgenden Text schön indenten.')+
+      br+
+      frage('Wie finden wir den <b>exit status</b> in ruby heraus?')+
+      cmd('Mittels der Variable $?')+
+      cmd('puts $?')+
+      br+
+      e('Auch kann man den existatus herausfinden:')+
+      br+
+      cmd('  $?.exitstatus == 0')+
+      br+
+      #cmd '  ruby -e "puts RUBY_VERSION.sub(/\.\d$/, \'\')"'
+      anm('$? ist rb_last_status(), und somit eine globale
+      Variable. Sie fungiert aber per-thread.')+
+      br+
+      frage('Wie loggen wir ein bei einem MUD, über telnet?')+
+      e('Zum Beispiel so:')+
+      br+
+      cmd('tn = Net::Telnet.new({})')+
+      cmd('tn.login "naghrazel", "xyz"')+
+      cmd('tn.cmd("l" ')+
+      cmd('tn.cmd("who"')+
+      br+
+      # ===================================================================== #
+      # === Dynamic Dispatch
+      # ===================================================================== #
+      frage('Was ist mit dem Begriff <b>Dynamic Dispatch</b> gemeint?')+
+      e('Dies ist wenn man wartet bevor man eine Methode aufruft
+      solange der Code läuft. Dies geschieht oft über die <b>.send</b>
+      Methode.')+
+      br+
+      frage('Ich möchte OS Kommandos und Shell Kommandos verwenden.
+      Wie kann ich dies in Ruby machen?')+
+      e('Verwende system() oder backticks `` oder exec()')+
+      br+
+      cmd('  system("./configure")')+
+      cmd('  system "echo *"')+
+      cmd('  system "ls"')+
+      br+
+      e('und')+
+      br+
+      cmd('`./configure\`')+
+      br+
+      e('are quite the same, whereas exec is if you want the current
+      process to become what you are/will be launching.')+
+      br+
+      anm('Man bemerke das system() entweder true oder false
+      zurückgibt.')+
+      br+
+      anm('Statt `` kann man übrigens auch dies hier verwenden:')+
+      br+
+      cmd('  result = %x{ uname }')+
+      br+
+      e('Man kann zudem <i>redirection</i> verwenden um die
+      Ausgabe am Bildschirm zu unterdrücken, wie zum Beispiel
+      so:')+
+      br+
+      cmd('lame > /dev/null')+
+      br+
+      anm('Man sollte auch bedenken, das Kernel `` backticks eine
+      Operation ist die blockiert. Die Hauptaufgabe muss somit
+      warten, bis das Ergebnis aus der backtick operation da ist.')+
+      br+
+      frage('Wie finde ich das Encoding heraus?')+
+      cmd('  p __ENCODING__')+
+      br+
+      frage('Wie übergebe ich Argumente an eine Methode in ruby?')+
+      cmd('  object.method(arg1, arg2)')+
+      br+
+      e('oder ohne Klammern')+
+      br+
+      cmd('  object.method arg1, arg2')+
+      br+
+      frage('Wie finde ich den Besitzer (Owner) einer Methode
+      heraus?')+
+      cmd('  1.method(:to_d).owner # => Integer')+
+      cmd('  "cat".method(:upcase).owner # => String')+
+      br+
+      frage('Wie finde ich heraus in welchem Objekt eine Methode
+      definiert ist?')+
+      cmd('  method = "cat".method :upcase')+
+      cmd('  method.receiver # => "cat"')+
+      br+
+      frage('Wie kann ich ein <b>class Alias</b> definieren, in ruby?')+
+      cmd("  class Foo; def self.bar; puts 'ok'; end; end;
+      Foo.singleton_class.send(:alias_method, :foo, :bar); Foo.foo")+
+      br+
+      frage('Wie erhalten wir den vollen Ruby-Version String?
+      RUBY_VERSION ist zu kurz.')+
+      cmd('  e RUBY_DESCRIPTION # => "ruby 2.6.3p62
+      (2019-04-16 revision 67580) [x86_64-linux]"')+
+      br+
+      frage('Wie erhalten wir die aktuelle Methode in ruby?')+
+      cmd('def foo')+
+      cmd2('  puts "I am in #{__method__}"')+
+      cmd('end')+
+      br+
+      cmd('  require "net/ftp"; Net::FTP.method(:open).parameters')+
+      cmd('  # => [[:req, :host], [:opt, :user], [:opt, :passwd],
+      [:opt, :acct]] (https://eval.in/180014)')+
+      br+
+      frage('Wie erhalten wir alle Konstanten im Encoding
+      namespace, in ruby?')+
+      br+
+      cmd('  Encoding.list')+
+      br+
+      # ===================================================================== #
+      # === tap in ruby
+      # ===================================================================== #
+      frage('Wie verwenden wir <b>.tap</b> in Ruby?')+
+      frage('Wie überprüfen wir auf UTF8 Strings?')+
+      cmd('  require "kconv"')+
+      cmd('  "test".isutf8')+
+      br+
+      frage('Wie requiren wir <b>relativ zum aktuellen Verzeichnis</b>?')+
+      cmd('  require_relative "../bla/eeeks.rb"')+
+      cmd('  require_relative "../../../home/x/DATA/PC/PROGRAMMING_LANGUAGES/RUBY/src/tools/tasks.rb"')+
+      br+
+      anm('Das ist erst seit Ruby 1.9 verfügbar.')+
+      br+
+      frage('Wie kann wir das <b>Encoding</b> zu BINARY setzen?')+
+      cmd("  Encoding.default_external = 'BINARY'")+
+      cmd("  Encoding.default_external = 'ASCII 8bit")+
+      br+
+      # ===================================================================== #
+      # === Wie lese ich eine Datei ein, in ruby
+      # ===================================================================== #
+      frage('Wie lese ich eine Datei ein, in ruby? (read self)')+
+      cmd('  puts File.read(__FILE__)')+
+      br+
+      frage('Wie erhalten wir alle Methoden in ruby?')+
+      e('Dies geht über <b>.instance_methods</b>')+
+      br+
+      # ===================================================================== #
+      # === Wie erhalten wir alle class methods und instance methods einer
+      #     Klasse
+      # ===================================================================== #
+      frage('Wie erhalten wir alle <b>class methods</b> und alle <b>instance 
+      methods</b> einer Klasse?')+
+      cmd('  Integer.methods # gives class methods')+
+      cmd('  Integer.instance_methods # gives instance methods')+
+      br+
+      # ===================================================================== #
+      # === How to use Autoload
+      # ===================================================================== #
+      frage('Was ist Autoload und wie verwenden wir es?')+
+      e('autoload funktioniert ähnlich wie require, aber es lädt nur
+      Dateien wenn auf eine Konstante deiner Wahl zugegriffen wird.')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd("  autoload :Daemonizable,  'thin/daemonizing'")+
+      cmd("  autoload :Logging,       'thin/logging'")+
+      br+
+      e('Methoden in diesem Teil werden erst ausgeführt wenn die Klasse
+      aufgerufen wird.')+
+      br+
+      e('Man kann detektieren ob eine Klasse auf ein <b>autoload</b> wartet:')+
+      br+
+      cmd("  autoload :X, 'x'")+
+      cmd("  puts 'X is awaiting loading.' if autoload?(:X)")+
+      br+
+      frage('Wie finde ich den Namen einer Methode heraus?')+
+      cmd('  method = "cat".method(:upcase)')+
+      cmd('  method.name # => :upcase')+
+      br+
+      frage('Was ist <b>self</b> in Ruby?')+
+      e('self ist eine read-only Variable die auf das aktuelle
+      Objekt (current object) zeigt.')+
+      br+
+      e('Ruby braucht self um seine instance variables zu finden.')+
+      br+
+      frage('Wie lassen wir ein externes Programm in ruby laufen?',
+      'externes_programm')+ # rf ruby externes_programm
+      cmd('def run(command, input = "")')+
+      cmd3("  IO.popen(command, 'r+') { |io|")+
+      cmd3('    io.puts input')+
+      cmd3("    io.close_write")+
+      cmd3("    return io.read")+
+      cmd('  }')+
+      cmd("  run 'wc -w','How many words are in this string, hmm?' # => 8\n")+
+      br+
+      frage('Wie kann ich lokale Variablen in einer Datei erstellen
+      und in einer anderen Dateien wiederverwenden?')+
+      e('Mittels:')+
+      br+
+      cmd('  TOPLEVEL_BINDING.eval File.read(file), 1')+
+      br+
+      frage('Wie vertausche ich 2 Variablen in Ruby? (How do i swap
+      two variables?)')+
+      cmd('  a, b = 2, 3')+
+      cmd('  a, b = b, a # swap here.')+
+      br+
+      frage('Was ist <b>==</b> in ruby?')+
+      e('== ist der "equality operator".')+
+      br+
+      e('Er hat auch eine Negationsform, und zwar !=')+
+      br+
+      a('http://ruby-doc.org/core/Object.html#method-i-instance_variable_defined-3F',
+        content: 'SELF')+
+      br+
+      frage('Wie finden wir heraus, ob eine instance variable definiert ist?')+
+      e('Mittels <b>.instance_variable_defined?</b>.')+
+      br+
+      cmd('  class Test; @foo = "hi"; end # => "hi"')+
+      cmd('  Test.instance_variable_defined? :@foo # => true')+
+      br+
+      frage('Gibt es einen Vorteil wenn wir <b>load</b> anstelle
+      von <b>require</b> verwenden?')+
+      e('Ja. load() erlaubt es uns eine Datei neu zu laden,
+      require nicht.')+
+      br+
+      frage('Wie erhalten wir floats als Ergebnisse in ruby?')+
+      s2('Verwende')+
+      cmd('8300.0/5324')+
+      br+
+      # ===================================================================== #
+      # Gets input. Mehrere Zeilen auf einmal.
+      # ===================================================================== #
+      frage('Wie kann ein User mehrere Zeilen eintippen als input
+      zu gets? Was ist der Record Separator? (Multiline input)',
+      'user_input')+
+      e('Der Record Separator ist - $/')+
+      br+
+      e('Es handelt sich um eine <b>predefinierte Variable</b>.')+
+      br+
+      e('Mit seiner Hilfe kann man das Verhalten von Methoden wie
+      gets und chomp beeinflussen. gets() ruft einen String ein
+      und inkludiert auch den Record Separator.')+
+      br+
+      e('Die .chomp Methode hingegen gibt einen String wieder der 
+      den Record Separator entfernt hat, ansonsten gibt es den 
+      originalen String unmodifiziert zurück.')+
+      br+
+      e('Das eintippen von mehreren Zeilen über gets() geht indem
+      man zu $/ assigned (redefinition), bevor man gets aufruft:')+
+      br+
+      cmd('$/ = "END"')+
+      br+
+      e('Das keyword ist dann hier <b>END</b>.')+
+      br+
+      e('Noch ein Beispiel hierzu:')+
+      br+
+      cmd('  "$/ = "*" # the "*" character is now the record separator')+
+      br+
+      e('When you redefine the record separator, this new character 
+      (or string ) will now be used by methods such as gets and chomp.')+
+      br+
+      e('For example:')+
+      br+
+      cmd('  $/= "world"')+
+      cmd('  s = gets() # user enters Had we but world enough and time')+
+      cmd('  puts s # displays Had we but world')+
+      br+
+      frage('Was ist eine <b>class method</b> in ruby?')+
+      e('Eine <b>class method</b> ist eine Methode, die unabhängig
+      von einem bestimmten Objekt aufgerufen werden kann.')+
+      br+
+      frage('Wie verhalten sich mixins?')+
+      e('mixed-in modules verhalten sich wie Superklassen.')+
+      br+
+      frage('Kann ich programmatisch eine lokale Variable erstellen?')+
+      e('Ja.')+
+      br+
+      cmd('  eval "t=2;t", IRB.conf[:MAIN_CONTEXT].workspace.binding')+
+      br+
+      frage('Wie bekomme ich alle Instance Variables? (get all ivars, 
+      all instance variables)')+
+      cmd('  foo = Foo.new')+
+      cmd('  pp foo.instance_variables')+
+      br+
+      frage('Wie öffnen wir eine Datei in ruby und geben ihren Inhalt
+      auf <b>STDOUT</b> wieder? Wie können wir eine derart geöffnete
+      Datei wieder schliessen, automatisch?','read_file')+
+      cmd('  File.open("text.txt") { |file|')+
+      cmd2('    file.each_line { |line| puts line }')+
+      cmd('  } # automatically close the file here.')+
+      br+
+      e('Wir könnten auch folgendes verwenden:')+
+      br+
+      cmd('  File.open(ENV["RUBY"]+"/ruby.cgi").each { |line|
+      puts line if line =~ /blue/ }')+
+      br+
+      e('(Entferne einfach die if-clause wenn man alles
+      ausgeben möchte.)')+
+      frage('Wozu dient .send?')+
+      e('Mittels .send kann man eine beliebige Methode in einem
+      Objekt aufrufen (sofern diese Methode auch <b>vorhanden</b>
+      ist. Beispiel:')+
+      br+
+      e("  'your_string'.send :length # => 11'")+
+      br+
+      anm('.send ist übrigens ein alias zu __send__')+
+      br+
+      e('Man kann auch Bestimmte Attribute setzen wenn es die 
+      Klasse erlaubt. Beispiel:')+
+      br+
+      cmd('d.attr=(99)')+
+      br+
+      cmd('d.send(:attr=, 99) # macht das selbe wie oben, nur verboser.')+
+      br+
+      frage('Wie lese ich Daten von einer .rb Datei ohne das Ruby
+      diese Daten interpretiert?','__END__')+
+      cmd('p DATA.read')+
+      cmd('__END__')+
+      br+
+      e('DATA.read liest die Information ein, die nach __END__ geschrieben 
+      ist. Man kann dies sogar verwenden um Configurations-Dateien in 
+      einer .rb Datei zu speichern.')+
+      br+
+      anm('Die Konstante <b>DATA</b> ist verfügbar sobald die __END__ 
+      Direktive in einer .rb Datei drinnen steht. Alles was dieser 
+      __END__ Direktive folgt ist dann Inhalt von DATA.')+
+      anm('DATA ist leider nur für $0 verfügbar.')+
+      br+
+      anm('DATA ist ein File Objekt. Man kann daher auch <b>DATA.pos</b>
+      verwenden.')+
+      br+
+      e('Man kann mittels <b>__END__</b> auch direkt YAML Code in
+      ein .rb <b>Skript</b> einfügen.')+
+      br+
+      frage('Wie erhalte ich das Default External Ruby Encoding via
+      Commandline?')+
+      cmd("  ruby -e 'p Encoding.default_external'")+
+      br+
+      frage('Wie verwende ich ein Objekt ohne Throwaway Variable?')+
+      cmd('  2.times.with_object([]) { |v, o| o << v }')+
+      br+
+      frage('Wie liste ich alle Dateien im Verzeichnis?')+
+      cmd("  pp Dir['./*']",'ls')+ # ls tag
+      br+
+      frage('Was ist der $LOAD_PATH und wie erweitere ich den $LOAD_PATH 
+      um neue Pfade? (Std Path)','load_path')+
+      e('Um den LOAD_PATH zu erweitern, macht man einfach dies.')+
+      br+
+      cmd("  $LOAD_PATH << '/home/x/DATA/PC/PROGRAMMING_LANGUAGES/'")+
+      br+
+      e('Nun ein paar erklärende Worte hierzu.')+
+      br+
+      e('Der LOAD_PATH hat all jene Pfade, die Ruby durchsucht,
+      um die Ruby Standard Library zu finden. Er ist also sehr
+      wichtig.')+
+      br+
+      e('Es gibt hier 3 konkrete Aliases die auf diesen LOAD_PATH
+      Zeigen:')+
+      br+
+      cmd('$:')+
+      cmd('$LOAD_PATH')+
+      cmd('$-I')+
+      br+
+      e('An diesen Wert kann man seine eigene Library anhängen.')+
+      br+
+      e('Dies geht auch über die command line, und zwar mittels
+      der <b>-I flag</b>.')+
+      br+
+      frage('Wie übergebe ich einen Hash an eine Methode? Wie sammel
+      ich Argumente die ich an eine Methode übergeben möchte?')+
+      cmd('def foo(arg1, *rest)')+
+      cmd2('  puts "Got #{arg1} and #{rest.join}"')+
+      cmd('end')+
+      br+
+      cmd('  foo("one") # => Got one and')+
+      cmd('  foo("one", "two") # => Got one and two')+
+      cmd('  foo("one", "two", "three") # => Got one and twothree')+
+      br+
+      e('Will man nun einen Hash an eine Methode übergeben so macht
+      man dies einfach so:')+
+      br+
+      cmd('  def foo(v)')+
+      cmd2('    pp v'  )+
+      cmd('  end')+
+      br+
+      cmd("  foo :name => 'checkbox', :job => 'hello hello..'")+
+      br+
+      frage('Wie können wir die <b>Extension</b> einer Datei entfernen?')+
+      cmd("  File.basename('stuff.rb', '.*')")+
+      br+
+      anm('Es ginge auch mit .gsub aber das ist nicht so elegant.')+
+      br+
+      frage('Wieso verwenden wir die superclass() Methode?')+
+      e('Die superclass() Methode gibt einem die Eltern-Methode
+      wieder ("parent method").')+
+      br+
+      e('Beispiel')+
+      br+
+      cmd('  puts "The superclass of Array is: #{Array.superclass}."')+
+      br+
+      anm('Die Superklasse von Array ist Object.')+
+      br+
+      frage('Wie kann ich die Warnungen von Ruby ausschalten?')+
+      cmd('  $VERBOSE = nil')+
+      br+
+      e('$VERBOSE kann 3 Zustände haben:')+
+      br+
+      lem('nil   - dies entspricht dem Wert 0, also "be silent".')+
+      lem('false - dies ist level 1, und ist der default.')+
+      lem('true  - dies ist level 2, für verbose.')+
+      br+
+      anm('Eine weitere Möglichkeit wäre es $stderr zu verwenden.')+
+      br+
+      frage('Wie können wir eine Variable definieren sofern sie noch
+      nicht definiert worden ist?', 'define_var_unless_already_defined')+ # rf ruby define_var_unless_already_defined
+      e('Verwende hierzu <b>||=</b>')+
+      br+
+      cmd('  hash = { :test => "foo"}')+
+      cmd('  your_var ||= hash[:test]')+
+      cmd('  your_var ||= 1')+
+      cmd('  pp your_var')+
+      br+
+      frage('Wie erhalte ich die ASCII Nummer eines Zeichens (letter)?
+      Und wie konvertiere ich diese Nummer in ein Zeichen?
+      (char to letter/number to letter/number to char)')+
+      cmd('?a')+
+      br+
+      e('dies würde den ASCII Code des Charakters a ausgeben.')+
+      br+
+      e('Es gibt noch einen anderen Weg den ASCII Code zu erhalten:')+
+      br+
+      cmd('  "a"[0] # => 97')+
+      br+
+      e('Specifying multiple ASCII code for several chars raises an error:')+
+      br+
+      cmd('?a')+
+      br+
+      e('Von Nummer zu Zeichen kann man folgenden code verwenden:')+
+      br+
+      cmd('  "97".map { |c| c.to_i.chr }')+
+      br+
+      e('Mittels der Methode <b>.chr</b> erhält man die Nummer.')+
+      br+
+      frage('Wie finden wir heraus ob eine Datei existiert, in ruby? (file
+      exists, file exist, dir exists, directory exists?)')+
+      cmd('  File.exist? filename')+
+      cmd('  File.exist? to_be_created')+
+      br+
+      e('oder')+
+      br+
+      cmd('  FileTest.exists?')+
+      anm('Dies kann auch verwendet werden um herauszufinden ob ein
+      Verzeichnis existiert.')+
+      br+
+      frage('Wie löschen wir eine Datei in ruby (file delete, del
+      file, delete file)?')+
+      cmd('  File.delete "testrm"')+
+      br+
+      frage('Wie erhalte ich Informationen über die Ruby Version?')+
+      e('Dies geht über die <b>RUBY_PLATFORM Konstante</b>.')+
+      br+
+      e('Dies mag zu Problemen bei <b>Virtual Machines</b> führen.')+
+      br+
+      e('Die Version kann man zum Beispiel wie folgt abfragen:')+
+      br+
+      cmd("  RUBY_VERSION == '1.8.7'")+
+      br+
+      frage('Wie kann ich verhindern das ein Objekt verändert wird
+      nachdem es erstellt wurde?')+
+      e('Verwende .freeze, wie in 
+      <span class="s1">object.freeze</span>')+
+      br+
+      e('Versucht man ein frozen Objekt zu verändern so
+      kommt es zu folgendem Fehler:')+
+      br+
+      e('TypeError: cant modify frozen object.')+
+      br+
+      e('Ist ein Objekt in diesem Sinne "tainted", so kann man die
+      Methode .untaint verwenden um dieses Objekt wieder "untaint"
+      zu setzen.')+
+      br+
+      e('Ein frozen Objekt kann jedoch <b>niemals</b> wieder
+      unfreezed werden - die Methode sollte daher nur dann
+      verwendet werden, wenn man ein frozen Objekt wirklich
+      benötigt.')+
+      # ===================================================================== #
+      # === /dev/null
+      # ===================================================================== #
+      frage('Wie erhalte ich eine Referenz zu /dev/null, die möglichst
+      Plattform-unspezifisch ist?')+
+      cmd('Mittels <b>IO::NULL</b>')+
+      frage('Wie zähle ich von 0 bis 10?')+
+      cmd("  p(*('0'..'F'))")+
+      br+
+      frage('Wie verwende ich <b>Resolv</b>?')+
+      cmd("  require 'resolv'")+
+      br+
+      cmd('  Resolv.getaddress "google.com"')+
+      cmd('  Resolv.getaddress "google.com" # => "64.233.167.99"')+
+      br+
+      frage('What are the highest numbers for Ruby?')+
+      e('You can easily use a googol which is')+
+      br+
+      cmd('googol = 10**100')+
+      br+
+      e('You will have an error mesage if you try to output a googolplex, like')+
+      br+
+      cmd('googolplex = 10**googol')+
+      br+
+      frage("Wie erhalte ich die Version von Ruby")+
+      cmd('  puts RUBY_VERSION')+
+      br+
+      e('If you want to get the major number without
+      the minor number, use:')+
+      br+
+      frage('Wie schreibe ich direkt zu STDOUT und STDERR?')+
+      cmd('  $stdout.puts "stdout"')+
+      cmd('  $stderr.puts "stderr"')+
+      br+
+      anm('Damit kann man dann direkt in eine Datei schreiben:')+
+      br+
+      cmd('  ruby stdout_stderr_test.rb > stdout 2> stderr')+
+      br+
+      frage('Wie verwende ich eine instance variable in Ruby?')+
+      e('Use')+
+      br+
+      cmd('@')+
+      br+
+      e('just before the variable, like this way')+
+      br+
+      cmd('@foo')+
+      br+
+      # ===================================================================== #
+      # === Wie finden wir den prefix von Ruby heraus?
+      # ===================================================================== #
+      frage('Wie finden wir den prefix von Ruby heraus?')+
+      cmd("  RbConfig::CONFIG['rubylibprefix'] # => \"/Programs/Ruby/2.6.3/lib/ruby\"")+
+      br+
+      # ===================================================================== #
+      # === Handling permissions in Ruby
+      # ===================================================================== #
+      frage('Wie handhaben wir <b>permissions</b> in ruby (zum
+      Beispiel überprüfen ob wir in eine Datei hineinschreiben
+      können)?')+
+      cmd('  if File.writeable(this_file)')+
+      br+
+      # ===================================================================== #
+      # === How to use "p foo".
+      # ===================================================================== #
+      frage('Wozu verwende wir <b>p</b>, wie zum Beispiel in
+      <b>p object</b>?')+
+      e('p gibt die interne Repräsentation eines Objekts wieder
+      (<i>internal representation of an object</i>), und das ganze
+      recht detailliert.')+
+      br+
+      cmd('  class Foo; def initialize;@test = 5;end;end;
+      foo = Foo.new; p foo # => #<Foo:0x988c9a4 @test=5>'
+      )+
+      br+
+      # ===================================================================== #
+      # === Wie lesen wir jedes Byte einer Datei ein?
+      # ===================================================================== #
+      frage('Wie lesen wir jedes Byte einer Datei ein?')+
+      e('Mittels <b>.each_byte</b>:')+
+      br+
+      cmd('File.open("/etc/passwd").each_byte { |byte| puts byte }')+
+      br+
+      e('Dies kann man mit .chr übersetzen.')+
+      br+
+      cmd('  109.chr # => "m"')+
+      br+
+      # ===================================================================== #
+      # === How to find out the name of a file in ruby
+      # ===================================================================== #
+      frage('Wie finden wir den Namen einer Datei heraus, in
+      Ruby?')+
+      e('Mittels:')+
+      br+
+      cmd('__FILE__')+
+      br+
+      e('__FILE__ ist übrigens ein <b>Keyword</b>.')+
+      br+
+      frage('Wie erhalten wir den absoluten Pfad der aktuellen
+      Dateien?')+
+      cmd("  Dir[Dir.pwd+'/*']")+
+      br+
+      frage('Was bedeutet ein @ vor einem Namen?')+
+      e('Dies erstellt eine instance variable.')+
+      br+
+      e('Eine instance variable ist standardmässig nur innerhalb der Instanz 
+      der Klasse greifbar.')+
+      br+
+      frage('Wie erhalte ich eine Liste mit Prozessen von Ruby?')+
+      cmd("  require 'sys/proctable'")+
+      cmd('  include Sys')+
+      br+
+      cmd('  ProcTable.ps{ |proc_struct| p proc_struct }')+
+      br+
+      frage('Wie verwenden wir die <b>bz2 library</b> mittels ruby?')+
+      cmd("  require 'bz2'")+
+      cmd('  include BZ2')+
+      br+
+      # ===================================================================== #
+      # === Ruby's Namespace Operator.
+      # ===================================================================== #
+      frage('Was bedeutet <b>::Foo</b> in ruby?','::')+ # rfruby ::
+      e('Dies erstellt eine Top Namespace. Der :: ist
+      der "Namespace Resolution Operator" in Ruby.')+
+      br+
+      e('Beispiel für die Verwendung von <b>::Foo</b>:')+
+      br+
+      cmd('  class Foo')+
+      cmd('  end')+
+      cmd('  module Bar')+
+      cmd2('    class A')+
+      cmd2('    end')+
+      cmd2('    p ::Foo # the top level one, not the normally scoped one')+
+      cmd('  end')+
+      br+
+      frage('Wie beende ich ein ruby script? (ruby quit, exit program, quit
+      program)')+
+      e('Verwende "exit".')+
+      br+
+      e('Man kann auch <b>abort</b>, mit einer Nachricht, verwenden.')+
+      br+
+      e('Eine weitere Möglichkeit ist der at_exit handler
+      (at exit, register exit): <b>at_exit {}</b>')+
+      br+
+      anm('at_exit kann oft auch verwendet werden wenn <b>END {}</b>
+      verwendet wird. Allerdings ist at_exit auch etwas mühsam.')+
+      br+
+      frage('Was bedeutet das Zeichen <b>^</b>?')+
+      e('Dies meint this-or, auch als <b>xor</b> bekannt. Man kann
+      damit conditionals testen, also ob eine Variable true oder
+      false ist.')+
+      br+
+      frage('Wie überprüfe ich die Klasse eines Objektes?','type_checking')+
+      cmd('  a.is_a? String')+
+      cmd('  5.is_a? Integer # => true')+
+      br+
+      # ===================================================================== #
+      # === Target platform of the OS
+      # ===================================================================== #
+      frage('Wie finde ich die Target Platform des OS heraus, unter ruby?')+
+      e('Verwende <b>RUBY_PLATFORM</b>')+
+      br+
+      e('Beispiel:')+
+      br+
+      cmd('  puts RUBY_PLATFORM')+
+      br+
+      frage('How can I make Ruby Objects persisting/surviving?')+
+      e('There are some solutions like storing in a yaml file, using
+      madeleine, Object Graph or hibernate, or marshalling.')+
+      br+
+      e('<a href="http://www.rubygarden.com/index.cgi/Libraries/og_tutorial.rdoc">
+      Object Graph </a>')+
+      br+
+      frage('Gibt es etwas zu require zu sagen?','require')+ # require tag
+      e('Die Dateien die bei <b>require</b> verwendet werden im 
+      Array <b>$"</b> gespeichert - also noch besser gleich 
+      <b>$LOADED_FEATURES</b> verwenden.')+
+      br+
+      e('Man kann - bequemerweise - global Variables und Methoden 
+      tracen. <b>Beispiel</b>:')+
+      br+
+      cmd('  trace_var :$x, proc {print "The global variable $x 
+      is now ", $x, "\n"}; $x = 8 # => The global variable $x is now 8')+
+      cmd('  $x=10')+
+      anm('Dies würde sich doch hervorragend für Events eignen. Leider
+      funktioniert trace_vor nur mit Globalen Variablen.')+
+      br+
+      anm('Man kann eine getracedte Variable auch wieder untracen:')+
+      br+
+      cmd('  untrace_var :symbol')+
+      br+
+      frage('Wie erhalte ich den PATH_SEPARATOR?')+
+      cmd('  File::PATH_SEPARATOR')+
+      br+
+      frage('Wie verwenden wir echten Parallelismus in Ruby?')+
+      e('Wir können <b>Process</b> verwenden.')+
+      br+
+      frage('Wie erhalten wir programmatisch die Klasse einer Methode?')+
+      cmd('  method(:function_name).class')+
+      cmd('  method(:function_name).object_id')+
+      br+
+      frage('Was meinen wir mit einem <b>Quine</b>?')+
+      e('Ein quine ist hier eine Datei, die ihren eigenen Quellcode
+      (== source code) ausgibt.')+
+      br+
+      frage('Wie kann ich Methoden miteinander verknüpfen (chainen, method chaining)?')+
+      e('Zum Beispiel via:')+
+      br+
+      cmd('array.flatten.uniq')+
+      br+
+      e('Hier ein einfaches, obgleich seltsames, Beispiel:')+
+      cmd('  def outhello')+
+      cmd2('    (((0..12).to_a + (0..12).to_a.reverse) * 2).each { |val|')+
+      cmd3('      print("****" * val + "* Hello, world! *" +')+
+      cmd3('       "****" * (12-val) + "\n")')+
+      cmd2('    } # each')+
+      cmd('  end # outhello')+
+      cmd('outhello')+
+      br+
+      frage('Was ist STDOUT und STDOUT.flush?')+
+      e('STDOUT ist der standard output. Er besitzt eine assoziierte
+      Nummer, die man mittels <b>STDOUT.fileno</b> herausfinden
+      kann (der Wert 1 scheint hierbei auf).')+
+      br+
+      e('STDOUT.flush wiederum stellt sicher, das das Terminal seinen
+      Buffer entleert, also wieder auf "leer" zurückgesetzt wird.')+
+      br+
+      e('Anders formuliert - was auch immer im buffer war, wird 
+      ausgegeben.')+
+      br+
+      e('Normally, the input is buffered line by line until it finds 
+      a newline ( \n )')+
+      br+
+      e('If a command does not produce a \n, it may be that the text will 
+      not be displayed at all. That is where STDOUT.flush comes in handy,
+      as we force-flush it.')+
+      br+
+      e('You can use puts instead of course.')+
+      br+
+      e('An alternative to STDOUT.flush you could try this:')+
+      br+
+      cmd('  STDOUT.sync = true')+
+      cmd('  print "Processing... "')+
+      br+
+      frage("Wo ist die Online Version von IRB?")+
+      a('http://tryruby.hobix.com/', content: 'http://tryruby.hobix.com/')+
+      frage('Wer ist der Ruby Held?','hero')+
+      img('PROGRAMMING_LANGUAGES/RUBY/MATZ_IS_MY_HERO.png',
+          'marl1em','ruby_held')+
+      br+
+      br+
+      div {
+        e('The error will be stored in <b>$?</b>.')+
+        br+
+        e('Du kannst auch die PID davon erhalten, zbsp:')+
+        br+
+        cmd('  `ls`; puts $?.pid; puts $?.exitstatus')+
+        br+
+        e('You can also use another syntax, for example:')+
+        br+
+        cmd('  %x{ echo "$CD"}.chomp')+
+        br+
+        e('system() does not capture output, so you cant use variables
+        within system which get calculated only the moment they exist,
+        like ENV["home"].')+
+        br+
+        e('To work with it, you must assign a variable to it.')+
+        br+
+        e('Alternatively you can use something like instead:')+
+        br+
+        cmd('`#{MAIN_COMMAND} 2>&1`')+
+        cmd('`make 2>&1`')+
+        cmd('  $?.exitstatus')+
+        cmd('  $CHILD_STATUS.exitstatus'
+        )+
+        br+
+        e('Alternativ kann man <b>popen</b> verwenden, siehe hierzu
+        mein <a href="#stdin">stdin Beispiel</a>.')+
+        br+
+        e('Wie vermeiden wir bestimmte Warnings?')+
+        br+
+        cmd("require 'warning'")+
+        cmd("Warning.ignore(/`(els)?if' at the end of line without an expression/)")
+      }+
+      # ===================================================================== #
+      # RUBY VARIABLES
+      # ===================================================================== #
+      div('pad12px bgreen1','RubyVariables'){
+        h2('VariablesAndRuby','s1em pad5px mar5px',
+           '','border-bottom:1px solid royalblue')+
+        # Table.enable_padding
+        table2('s2em mar2px bblack3 marl2em','_','TableRubyVariables',
+          '$','global variable',
+          '@','instance variable',
+          '[a-z]','local variable',
+          '[A-Z]','constant'
+        )
+      }+
+      div {
+        frage('Wie können wir vordefinierte Konstanten in den
+        File Modes verwenden?')+
+        h4('Open-mode constants','marl1em')+
+        table2('s4em','','',
+          'APPEND','Open the file in append mode; all writes will 
+                    occur at end of file',
+          'CREAT ','Create the file on open if it does not exist',
+          'EXCL  ','When used with CREAT, open will fail if the file exists.',
+          'NOCTTY','When opening a terminal device, do not allow it to 
+                    become the controlling terminal',
+          'NONBLOCK','Open the file in nonblocking mode',
+          'RDONLY','Open for reading only',
+          'RDWR ', 'Open for reading and writing',
+          'TRUNC ','Open the file and truncate it to zero length 
+          if the file exists',
+          'WRONLY','Open for writing only'
+        )+
+        br+
+        e('Beispiel hierzu:')+
+        br+
+        h4('<b class="marl2em">
+        f = File.new("newfile", File::CREAT|File::TRUNC|File::RDWR, 0644)
+        </b>')
+      }+
+      # ===================================================================== #
+      # HeadlineRubyCommandlineOptions
+      # ===================================================================== #
+      div('pad8px bgreen1','CommandlineOptions'){
+        h2(
+          sg(:yellow_dot,'marr4px')+
+          "Ruby's commandline options",
+          's1em FI pad5px mar5px',
+          'HeadlineRubyCommandlineOptions',
+          'border-bottom:1px solid royalblue'
+        )+
+        table2('marl2em s1em','CommandlineOptionsTable','',
+          '0[DIGIT]','paragraph mode',
+          'a','auto split mode','c','syntax checking only',
+          'e SCRIPT','specifies the SCRIPT on command line',
+          'F\'DELIMITOR\'','specifies delimitor',
+          'i[extention]','in-place editing mode',
+          'I DIRECTORY','specities load path',
+          'l','remove NEWLINE from input and put NEWLINE to output',
+          'n','automatic loop',
+          'p','automatic loop with output',
+          'v','prints version, verbose mode'
+        )+
+        h4('  require "English"')+
+        table2(
+          'marl2em s1em mar2px bblack1','anhang','EnglishlibraryTable',
+          '$*', '<b>$ARGV</b>',
+          '$?', '<b>$CHILD_STATUS</b>',
+          '$<', '<b>$DEFAULT_INPUT (Equivalent to ARGF)</b>',
+          '$>', '<b>$DEFAULT_OUTPUT</b>',
+          '$!', '<b>$ERROR_INFO</b>',
+          '$@', '<b>$ERROR_POSITION</b>',
+          '$/', '<b>$INPUT_RECORD_SEPARATOR</b>',
+          '$;', '<b>$FIELD_SEPARATOR or $FS</b>',
+          '$=', '<b>$IGNORECASE</b>',
+          '$.', '<b>$INPUT_LINE_NUMBER</b>',
+          '$~', '<b>$LAST_MATCH_INFO</b>',
+          '$+', '<b>$LAST_PAREN_MATCH</b>',
+          '$_', '<b>$LAST_READ_LINE</b>',
+          '$"', '<b>$LOADED_FEATURES</b>',
+          '$&', '<b>$MATCH</b>',
+          # '$.', '<b>$NR</b>', # hmmm 2x das selbe?
+          '$,', '<b>$OFS</b>',
+          '$\\','<b>$ORS</b>',
+          '$,',' <b>$OUTPUT_FIELD_SEPARATOR</b>',
+          '$\\','<b>$OUTPUT_RECORD_SEPARATOR</b>',
+          '$$',' <b>$PID aka $PROCESS_ID</b>',
+          '$\'','<b>$POSTMATCH</b>', # $\'
+          '$`',' <b>$PREMATCH</b>',
+          '$0',' <b>$PROGRAM_NAME</b>',
+          '$/',' <b>$RS</b>'
+         )
+      }
+    }
+    }
+  end
+
+end