roebe 0.5.187

data/doc/core/misc.md

@@ -0,0 +1,1779 @@
+## How do we find out how many arguments a method will accept? (alos known as arity)
+
+  This is possible via the <b>.arity</b> method.
+
+  Example for this:
+
+    'sss'.method(:concat).arity # => -1
+    'sss'.method(:size).arity   # => 0
+    method(:method_name).arity
+    instance_method(:method_name).arity
+
+## How do we change the value of a true variable to false and vice versa?
+
+  Use ^= as in:
+
+    var ^= true
+
+  Alternatively you could use the ternary operator, such as via:
+
+    var = condition ? true_val : false_val
+    1 ^ 0  # => 1
+    1 ^ 1  # => 0
+    0 ^ 0  # => 0
+    0 ^ 1  # => 1
+
+  A slightly more complex example follows:
+
+    r if !r.nil? and r != "" and (command.nil? || command.empty?)
+    if ARGV[0] == ( 'no' or 'n' )
+
+## How to quickly obtain the SITE LIB DIR in ruby via a method?
+
+    def ruby_sitelib_dir?
+      RbConfig::CONFIG['sitelibdir'].to_s+'/'
+    end
+
+## How to encode a String in ruby, towards a specific Encoding?
+
+    puts 'äöü'.encode('iso-8859-1')
+
+## How to avoid that local variables vanish, that is, to "evaporate"?
+
+  One of the best strategy to avoid this issue is to store information
+  in instance variables, such as <b>@foobar</b>.
+
+## How to determine the current encoding of a file?
+
+  Use:
+
+    __ENCODING__
+
+## How do we write a <b>Domain Specific Language</b> (DSL), in Ruby?
+
+  First, we should denote what the goals are for that DSL.
+
+  Next, one should note down how to achieve these goals specifically.
+
+  For my biology-environment I thought about adding a hierarchy
+  of different classes, without specifying which class is to
+  be used.
+
+  Example:
+
+    subclasses [listing of them goes here]
+
+  The main idea behind a DSL is that the language is adjusted towards
+  the problem at hand, rather than using a programming language 
+  per se, to solve a given problem.
+
+## How to determine whether a method is public or not, in ruby?
+
+    .public_method_defined?
+
+## Which _eval methods exist?
+
+    Object#instance_eval
+    Module#class_eval
+    Module#module_eval
+
+## How does ruby's include directive works?
+
+  Via <b>include</b> ruby creates a reference from the given class
+  onto the module that is included. If several classes include the
+  same module then each of them will also be changed, naturally,
+  if this module is modified.
+
+  The basic syntax in how to include a module goes like this:
+
+    class Foo
+
+      nclude Bar
+
+    end
+
+## How can we define a singleton method in Ruby?
+
+  At the least two different ways exist there:
+
+    c = 'cat'; c.define_singleton_method(:hi) { p 'hi' }
+    c = 'cat'; def c.hi; p 'hi'; end
+
+## Is it possible to combine <b>protected</b> with <b>attr_accessor</b>?
+
+  Yes.
+  
+  Use:
+
+    attr_accessor :foo; protected :foo, :foo=
+
+## How do we seek and write in a file?
+
+  This is possible by using <b>r+b</b> and seek().
+
+  Example:
+
+    File.open('test.txt','wb'){|f| f.print 'A' * 1024 }
+    File.open('test.txt','r+b'){|f| f.seek(512); f.print 'BBBB' }
+
+## How do we find out whether xyz is a file? (is file, is file?, is_file?)
+
+  Use:
+
+    File.file?(xyz)
+    File.file? file
+
+## How can we copy a file in ruby? (copy tag, copy_file tag)','copy
+
+    FileUtils.cp(from, to)
+
+## How do we view all methods on a given object?
+
+  Use:
+
+    object.public_methods(false)
+
+
+## How can we use a case statement (case/when menu) in ruby without an explicit variable?
+
+  The following example shows this:
+  
+    print 'Enter a string: '
+
+    some_string = gets.chomp
+
+    case
+    when some_string.match(/\d/)
+      puts 'String has numbers'
+    when some_string.match(/[a-zA-Z]/)
+      puts 'String has letters'
+    else
+      puts 'String has no numbers or letters'
+    end
+
+## How do we obtain a <b>reference</b> to define_method?
+
+    D = Object.method(:define_method)
+
+## Where is the <b>SITELIBDIR</b> of Ruby?
+
+  Use the following to find out:
+
+    RbConfig::CONFIG['sitelibdir'] => '/Programs/Ruby/2.6.3/lib/ruby/site_ruby/2.6.0'
+
+## How do we read in a file in Ruby with explicit mention of the encoding?
+
+    this_file =
+    '/home/x/programming/ruby/documentation/ruby_errorcodes.cgi'
+    File.read(this_file, encoding: 'iso8859-1')
+
+    a = "abc".force_encoding("UTF-8")
+    string.force_encoding('UTF-8')
+    b = "def\xff".force_encoding("ISO-8859-1")
+
+  Another interesting way to open a file goes via:
+
+    File.read("chinese.txt", encoding: "UTF-8")
+    File.binread("foo.jpg")
+
+  One should be careful with encoding-related issues, as these may
+  yield to errors such as: <b>invalid multibyte char (US-ASCII)</b>
+
+## Please show a specific example how to talk to a network, via Ruby:
+
+    require 'socket'
+    client = TCPSocket.open('127.0.0.1','finger')
+    client.send("mysql\n",0) # means standard packet
+    puts client.readlines
+    client.send("ssl\n",0) # means standard packet
+    puts client.readlines
+    client.close
+
+## Which instances of class FalseClass exist in Ruby?
+
+  Only the value of false is an instance of class FalseClass.
+
+## How do we obtain the parameters of a method?
+
+    def foo(a, b = 6, c = 7)
+      method(__method__).parameters
+    end
+
+## How do we define methods dynamically?
+
+  We can use <b>define_method()</b> to define methods dynamically.
+
+    def method_missing(m)
+      puts "The method #{m} is not existing, so it will be defined dynamically."
+      define_method(:screech) {
+        puts 'This is the new screech.'
+      }
+    end
+
+  define_method() is a private class method - it thus has to be called
+  within the context of a class, without an explicit receiver.
+
+  define_method() belongs to class Object by default.
+
+  Let's look at the above snippet again and extend it:
+
+    def method_missing(m)
+      puts "No #{m}, so I will make one..."
+      self.class.define_method(:screech) {
+        puts 'This is the new screech.'
+      }
+    end
+    class C
+
+      class << self 
+        define_method(:tag) { |v|
+          puts "<#{v}><#{v}>"
+        }
+      end
+    end
+
+    C.tag('div') => <div></div>
+
+## Is there a drawback when we use setup.rb as opposed to a .gem file?
+
+  Yes - setup.rb does not offer an <b>uninstall</b> option.
+
+## How do we typically install ruby via setup.rb?
+
+  Use the following steps:
+
+    ruby setup.rb config
+    ruby setup.rb setup
+    ruby setup.rb install
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+      frage('Wie können wir einen Integer in Ruby konvertieren? Allgemein,
+      welche Möglichkeiten haben wir wenn wir etwas konvertieren wollen?
+      (convert an integer, convert tag)
+    Ruby verwendet sogenannte "conversion protocols" - ein Objekt kann
+      in ein anderes Objekt konvertiert werden.
+    Use <span class="s1">to_i</span> to convert in einen Integer,
+      <span class="s1">to_f</span> to convert to a float,
+      <span class="s1">to_s</span> to convert to a string.
+
+    Examples are easy, 
+      <span class="s1">366.to_s</span>  would make a "366" string,
+      and by appending an ?(type) to is_a you can find out what type it 
+      is (i.e whether it is true that
+      something is of this type). Example:
+      <span class="s1">366.is_a?(Integer)</span>,
+      <span class="s1">366.is_a?(Float)</span>,
+      <span class="s1">366.is_a?(String)</span> <br/>
+      The exists a .to_int method, but it only works on objects
+      that emulate integers.
+      Thus, it excludes String. <br/>
+      It is a convention: <br/>
+      The short names (to_s, to_i etc.) are to support conversion
+      and change an object into string.
+
+    to_str, to_int etc. are to support protocol or for
+      "behaving like a string" (in case of to_str). Diese sind
+      strengere Funktionen - man verwendet sie in einem 
+      Objekt nur wenn das Objekt normalerweise auch als String
+      oder Integer behandelbar ist.
+
+      What does a=(b != c) mean?")+
+     a is either true or false, depending on whether b != c is true or false
+      $CIU ranges as conditions?")+
+    Yes.
+
+      while line = gets
+        puts line if line =~ /start/ .. line =~ /end/
+      end
+
+    
+
+      frage('How do i make multiple if conditions?
+      cmd("if x == 'vid' or x == 'video'")+
+          puts "Is a vid"
+      end
+
+    Another example:
+
+      puts "hmm" if "foo" =~ /foo/ and "faa" =~ /faa/ and 5 > 2
+
+      frage('Can you show me an example for a menu, like a case expression driven one?
+    Yes, I can, I will, for I am the Ruby God!
+    There are two forms:
+
+      leap = case
+      when year % 400 == 0: true
+      when year % 100 == 0: false
+      end
+
+    And this one:
+
+      case input_line
+      when "debug"
+      dump_debug_info
+      dump_symbols
+      when /pü\s+(\w+)/
+      dump_variable($1)
+      when "quit","exit"
+      exit
+      else
+          print "Illegal Command:#{input_line}"
+      end
+
+    Und noch eines ...
+
+      case $age
+    <span class="s1">
+      when 0 .. 2  <br/>
+        "baby"  <br/>
+      when 3 .. 6   <br/>
+        "little child"  <br/>
+      when 7 .. 12  <br/>
+        "child"  <br/>
+      when 12 .. 18  <br/>
+    </span>
+      # Note: 12 already matched by "child" 
+      youth
+      else
+      adult
+      end
+
+
+      Another one :)
+      loop {
+        puts &#60;&#60;EOF
+      +--------------------+
+      | Please choose one: |
+      | 1. Add user        |
+      | 2. Remove user     |
+      +--------------------+
+      EOF
+
+        print "Your choice (1-2)?"
+          STDOUT.flush
+        line = gets
+        break if [1,2].include?(line.to_i)
+          puts "Invalid entry"
+      }
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+      h2('RubyReservedKeywords','BG_Black lightblue s1em pad5px mar5px',
+         'RubyReservedKeywords',
+         'border-bottom:1px solid royalblue;')+
+      table2('BG_Black yel s1em mar2px bblack1 marl4em',
+        'RubyReservedKeywords','',
+        'alias',    'and',
+        'BEGIN',    'begin',
+        'break',    'case',
+        'class',    'def',
+        'defined?', 'do',
+        'else',     'elsif',
+        'END',      'end',
+        'ensure',   'false',
+        'for',      'if',
+        'in',       'module',
+        'next',     'nil',
+        'not',      'or # is Synonym zu || jedoch hat || eine höhere Binding priority',
+        'redo',     'rescue',
+        'retry',    'return',
+        'self',     'super',
+        'then',     'true',
+        'undef',    'unless',
+        'until',    'when',
+        'while',    'yield'
+      )
+   
+
+
+
+
+
+
+
+
+
+
+      img('PROGRAMMING_LANGUAGES/RUBY/RUBY.png','FLL
+      img('PROGRAMMING_LANGUAGES/RUBY/RUBY_HYDRA.png',
+      
+
+      # ===================================================================== #
+      # === Count frequency of a word
+      # ===================================================================== #
+      div {
+        frage("Wie zähle ich die frequency eines Wortes? (word count, word
+        frequencies)
+        freq = Hash.new(0)
+        open("/home/x/DATA/RPG/RPG.php").read.scan(/\w+/){ |wort| freq[wort] += 1 }
+        freq.sort.each { |wort, zahl| puts "#{wort} - #{zahl}" }
+  
+      oder etwas kürzer:
+  
+        freq = Hash.new(0)
+        file = "kaiser.rb"
+  
+        open(file).read.scan(/\w+/) { |wort| freq[wort] += 1 }
+        freq.sort.each { |wort, zahl| puts "#{wort} - #{zahl}" }')
+      }+
+## What is a container?
+    Containers are <b>objects</b> that hold references to one or
+      more other objects.
+
+    Das verwendet man, da manche Terminals kleine Datenmenge
+      abpuffern und nicht aussenden.
+
+    Das "flushing" sendet die Datenmenge auf einmal raus und
+      mit <b>.sync = true</b> wird dies erzwungen.
+
+    Über Commandline Optionen geht dies so:
+
+      ruby -e "STDOUT.sync = true"
+
+    Dies erstellt ein Objekt der Klasse UnboundMethod.
+
+      x = Array.instance_method("pop") # => #<UnboundMethod: Array#pop>
+      string = String.instance_method(:size) # => #<UnboundMethod: String#size>
+
+
+
+## Was sind die grundlegenden Typen (Types) in Ruby?
+    Numbers, strings, arrays, hashes, ranges, symbols, regular
+      expressions.
+
+      # ===================================================================== #
+      # === Wie verwenden wir .instance_exec() in Ruby?
+      # ===================================================================== #
+## Wie verwenden wir .instance_exec() in ruby?
+    Ruby 1.9 hat die Methode <b>instance_exec()</b> hinzugefügt.
+
+    Diese funktioniert ähnlich wie instance_eval(), aber sie
+      erlaubt einem auch, Argumente an einen Block zu übergeben:
+
+      class C
+      cmd2('    def initialize
+      cmd3('      @x, @y = 1, 2
+      cmd2('    end
+      end
+
+      C.new.instance_exec(3) {|arg| (@x + @y) * arg }
+      # => 9
+
+      anm('An dieser Stelle sei noch ein Unterschied zwischen
+      <b>instance_eval</b> und <b>class_eval</b> bemerkt:
+
+      lem('class_eval definiert instance_methods da man sich im
+      Körper einer Klasse befindet.
+
+      lem('instance_eval agiert als ob man innerhalb von self
+      Methoden definieren würde, also erhält man damit class
+      methods.
+
+    Beispiel für .instance_eval:
+
+    class Foo; end
+
+    Foo.instance_eval {
+        def test
+          puts "this is a test"
+        end
+      }
+    Foo.test
+
+      anm('Man kann mittels .instance_eval auch Konstanten definieren:
+
+      module Foo; end; Foo.instance_eval { self::BAR = :b }
+
+    Es gibt seit Ruby 1.9 eine weitere Methode wie man das ganze
+      machen kann:
+
+    Mittels .instance_exec.
+
+    animal = "cats"
+    "dogs".instance_exec(animal) {|other|
+        puts "#{other} and #{self}" 
+      }
+      pp object.instance_methods
+
+    .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.
+
+      object.class.instance_methods(false)
+
+    Noch ein Beispiel, unter Verwendung von
+      .public_methods:
+
+      class Foo; def test1; end; def test2; end; end; 
+      Foo.new.public_methods(false) # => [:test1, :test2]
+
+    Ist alias wunderbar?
+
+    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.
+
+
+
+## Wie erhalte ich den Class Name einer Klasse?
+    Dies geht entweder so:
+
+      foo.class.name.split('::').last
+
+    Oder mittels Yard über .class_name.
+
+      module Hello; class Baby; end; end Hello::Baby.class_name # => "Baby"
+   
+## Wie setze ich Default Werte?
+    Am elegantesten geht dies wohl wie folgt:
+
+      def name; @name ||= "This is the default value for the
+      variable @name"; end
+
+      # ===================================================================== #
+      # === Wie pingen wir in ruby?
+      # ===================================================================== #
+## Wie pingen wir in Ruby?
+      Ping.pingecho "google.com", <timeout>, <port>
+      Ping.pingecho "google.com", 1 # => false
+
+    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)
+
+      frage("Wie schalte ich das Buffern von Strings aus? (disable String
+      Buffering, disable buffering)",'stdout
+      $stdout.sync = true','buffering # rf rubydocu buffering
+      $stderr.sync = true
+
+    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.
+ 
+
+
+## Was meinen wir mit den Attributen eines Objekts, in ruby?
+    Dies sind die <b>external sichtbaren Facetten</b> eines Objekts.
+
+## Wie finde ich möglichst viel über die <b>Plattform</b> raus,
+      auf der Ruby rennt?
+      require 'mkmf'
+      pp CONFIG
+
+
+
+## Wie finden wir den Namen eines Anwenders heraus wenn ich
+      seine UID habe?
+     Etc.getpwuid(0)
+
+## Was sind <b>Hooks</b> in ruby?
+    Hooks sind bestimmte Methoden die Ruby automatisch aufruft.
+
+    Wenn eine Klasse eine Class Method namens <b>.inherited</b> 
+      definiert so ruft Ruby diese auf wann immer die Klasse subclassed
+      wird.
+
+      def self.inherited(i)
+      cmd2('    @array << i
+      end
+
+## Wie verwenden wir quantity, in ruby?
+      require 'quantity/all'
+
+      1.meter                                              # => 1 meter
+      1.meter.to_feet                                      # => 3.28083... foot
+      c = 299792458.meters / 1.second                      # => 299792458 meter/second
+      newton = 1.meter * 1.kilogram / 1.second ** 2        # => 1 meter*kilogram/second^2
+      newton.to_feet                                       # => 3.28083989501312 foot*kilogram/second^2
+      newton.convert(:feet)                                # => 3.28083989501312 foot*kilogram/second^2
+      jerk_newton = newton / 1.second                      # => 1 meter*kilogram/second^3
+      jerk_newton * 1.second == newton                     # => true
+      mmcubed = 1.mm.cubed                                 # => 1 millimeter^3
+      mmcubed * 1000 == 1.milliliter                       # => true
+      [1.meter, 1.foot, 1.inch].sort                       # => [1 inch, 1 foot, 1 meter]
+      m_to_f = Quantity::Unit.for(:meter).convert_proc(:feet)
+      m_to_f.call(1)                                       # => 3.28083... (or a Rational)
+
+## Wie verwenden wir <b>defined?</b>, in ruby?
+    defined? ist ein merkwürdiges Keyword das einem nil zurückgibt
+      wenn das Argument unbekannt ist. Ansonsten gibt es einem den
+      Wert wieder.
+
+    Beispiele zu <b>defined?</b>:
+
+      defined? some_method # => nil
+      def test; end; defined? test # => "method"
+      super if defined? super
+
+## Wie erhalten wir eine bestimmte instance variable in ruby?',
+      'get_instance_variable # get ivar tag.
+    Mittels instance_variable_get.
+
+    Beispiel:
+
+      object.instance_variable_get '@foo'
+      self.instance_variable_get '@foo'
+
+    Mittels instance_variable_set setzt man eine Variable
+      (set ivar, ivar set):
+
+      object.instance_variable_set
+
+      object.instance_variable_set(symbol, object) => object
+      object.instance_variable_set(:@a, 'dog') # => 'dog'
+      object.instance_variable_set(:@c, 'cat') # => @c is now = 'cat'
+
+      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.
+
+    - Ein Block kann selbst ein block argument übernehmen in Ruby 1.9:
+
+      l2em('|arg1,arg2,&block|
+
+    .chr akzeptiert seit 1.9 auch Encoding:
+
+      322.chr("UTF-8") # => "kann man nicht darstellen hier aber es is 
+      so eine Art I mit schrägem Strich durch"
+
+      # ===================================================================== #
+      # === Können wir mehrere BEGIN und END Blöcke in einer .rb Datei
+      #     verwenden?
+      # ===================================================================== # 
+## Können wir mehrere BEGIN und END Blöcke in einer .rb Datei
+      verwenden?
+    Ja. BEGIN wird sequenziell abgearbeitet, END wird
+      umgekehrt-sequenziell abgearbeitet.
+
+    Ruby definiert die globals <b>false</b> und <b>nil</b>.
+      Das sind die einzigen beiden Werte die als "false"
+      interpretiert werden.
+
+
+## Wie kann ich den Namen der aktuellen Methode herausfinden?
+      Wie finde ich den Namen einer Methode heraus?
+    Dies geht mittels <b>Kernel.__method__</b>
+
+    Beispiel:
+
+    def foo
+      cmd2('  puts __method__
+    end
+
+      anm('__method__ gibt ein <b>Symbol</b> zurück.
+
+## Wie lese ich den MBR?','mbr # mbr tag
+      File.open("/dev/sda") {|f| f.read(512) }
+
+## Wie finde ich heraus wo eine Methode definiert ist?
+    Mittels <b>.source_location</b>
+
+    Man kann <b>.source_location</b> auf jede Methode in Ruby 1.9
+      anwenden.
+
+    Beispiele:
+
+      internal_method = "cat".method(:upcase)
+      internal_method.source_location # => nil
+      class A; def foo; end; end; file, line = A.instance_method(:foo).source_location
+
+## Wie generiere ich ein zufälliges Passwort - der beantworte
+      eine Frage zufällig mit yes oder no?
+      password = (1..8).map { chars[rand(chars.size)] }.pack("C*")
+
+    The answer is
+
+      %w(no yes).rand
+
+## Wie lesen wir einzelne Chars in ruby ein?
+    Verwende hierzu io-console von http://www.rubyist.net/~nobu/ruby/
+
+      a('http://www.rubyist.net/~nobu/ruby/io-console.tar.bz2',
+        content:'Io Console
+
+      require 'io/console.so'
+
+      print STDIN.getch
+
+## Wie bekomme ich die Zeile des Fehlers?
+      puts "Failed to load in #{__FILE__}:#{__LINE__}"
+
+## 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
+
+    Dies geht entweder mittels <b>method_defined?</b> oder mittels
+      <b>respond_to?</b>.
+
+      method_defined?
+      unless method_defined? :your_method
+      Array.method_defined?("size") # => true
+      Array.method_defined?(:bsearch)
+      if !method_defined? :to_time
+
+    Der Vorteil ist das man hier Methoden konditional hinzufügen
+      kann.
+
+    Noch ein Beispiel hierzu:
+
+      class Foo;def test;end;end
+      Foo.method_defined? :test # => true
+
+## Wie verwenden wir Symbol#to_proc?
+    Nun... & ist ein Alias zu to_proc. & calls #to_proc
+
+
+## Wie erhalte ich alle Argumente, die eine Methode in
+      Ruby benötigt?
+      A.instance_method(:method1).parameters # => [[:req, :tuti], [:req, :fruity]]
+      module Foo; def method1(tuti, frutti); end; end
+
+      Foo.instance_method(:method1).parameters.map(&:last).map(&:to_s)
+      # => ["tuti", "frutti"]
+
+## Wie wird der <b>stack trace</b> normalerweise produziert?
+    Mittels der <b>Kernel.caller</b> Methode.
+      br  +
+## Wie konvertiere ich einen <b>HEXSTRING</b>?
+      "FF00FF".scan(/../).map(&:hex).map(&:chr).join 
+
+## Wie laden wir Dateien die relativ zu anderen
+      Dateien sind, in ruby?','expand_path # relative requires.
+      require File.join(File.dirname(__FILE__), "foo", "bar")
+      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.
+
+    File.expand_path gibt den absoluten Pfad wieder.
+
+    __FILE__ ist der Pfad zu der Datei.
+
+## Wie können wir in Ruby einen Datensatz gruppieren?
+      (group by first letter)
+      birds = ["Golden Eagle", "Gyrfalcon", "American Robin", 
+      "Mountain BlueBird", "Mountain-Hawk Eagle"]
+      grouped_by_first_letter = birds.group_by { |s| s[0] }
+
+    Wie finden wir heraus ob eine Instance Variable definiert
+      wurde? # is instance variable defined.
+      if self.instance_variable_defined? "@foo"
+      object.instance_variable_defined?("@foo") # => true
+      object.instance_variable_defined? "@var" # => true
+
+## Und wie entferne ich eine instance variable wieder?
+    Mittels remove_instance_variable. Beispiel:
+
+      remove_instance_variable(:@foo)
+
+      anm('Man kann auch konditional überprüfen ob eine Methode
+      in dem übergeordnetem Objekt existiert:
+
+      if defined?(super)
+      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)
+
+## Was ist SCRIPT_LINES__?
+    SCRIPT_LINES__ (Hash)
+
+    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.
+
+    See Kernel.require for an example, and then over
+      in Kernel.require:
+
+    The SCRIPT_LINES__ constant can be used to capture the 
+      source of code read using require.
+
+## Verwendet Ruby heredoc? (heredoc tag)
+    Ja. Alles das zwischen TOKEN ist wird gedruckt.
+
+    Beispiel:
+
+    print << X
+      cmd2('  kl
+      cmd2('  gegekl
+      cmd2('  kl
+      cmd2('  kl
+
+    X','indianred
+
+    Übrigens - wenn man ein Minuszeichen nach den beiden < setzt 
+      dann kann man den folgenden Text schön indenten.
+
+## Wie finden wir den <b>exit status</b> in ruby heraus?
+    Mittels der Variable $?
+    puts $?
+
+    Auch kann man den existatus herausfinden:
+
+      $?.exitstatus == 0
+
+      #cmd '  ruby -e "puts RUBY_VERSION.sub(/\.\d$/, \'\')"'
+      anm('$? ist rb_last_status(), und somit eine globale
+      Variable. Sie fungiert aber per-thread.
+
+## Wie loggen wir ein bei einem MUD, über telnet?
+    Zum Beispiel so:
+
+    tn = Net::Telnet.new({})
+    tn.login "naghrazel", "xyz"
+    tn.cmd("l" 
+    tn.cmd("who"
+
+      # ===================================================================== #
+      # === Dynamic Dispatch
+      # ===================================================================== #
+## Was ist mit dem Begriff <b>Dynamic Dispatch</b> gemeint?
+    Dies ist wenn man wartet bevor man eine Methode aufruft
+      solange der Code läuft. Dies geschieht oft über die <b>.send</b>
+      Methode.
+
+## Ich möchte OS Kommandos und Shell Kommandos verwenden.
+      Wie kann ich dies in Ruby machen?
+    Verwende system() oder backticks `` oder exec()
+
+      system("./configure")
+      system "echo *"
+      system "ls"
+
+    und
+
+    `./configure\`
+
+    are quite the same, whereas exec is if you want the current
+      process to become what you are/will be launching.
+
+      anm('Man bemerke das system() entweder true oder false
+      zurückgibt.
+
+      anm('Statt `` kann man übrigens auch dies hier verwenden:
+
+      result = %x{ uname }
+
+    Man kann zudem <i>redirection</i> verwenden um die
+      Ausgabe am Bildschirm zu unterdrücken, wie zum Beispiel
+      so:
+
+    lame > /dev/null
+
+      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.
+
+## Wie finde ich das Encoding heraus?
+      p __ENCODING__
+
+## Wie übergebe ich Argumente an eine Methode in ruby?
+      object.method(arg1, arg2)
+
+    oder ohne Klammern
+
+      object.method arg1, arg2
+
+## Wie finde ich den Besitzer (Owner) einer Methode
+      heraus?
+      1.method(:to_d).owner # => Integer
+      "cat".method(:upcase).owner # => String
+
+## Wie finde ich heraus in welchem Objekt eine Methode
+      definiert ist?
+      method = "cat".method :upcase
+      method.receiver # => "cat"
+
+## Wie kann ich ein <b>class Alias</b> definieren, in ruby?
+      class Foo; def self.bar; puts 'ok'; end; end;
+      Foo.singleton_class.send(:alias_method, :foo, :bar); Foo.foo
+
+## Wie erhalten wir den vollen Ruby-Version String?
+      RUBY_VERSION ist zu kurz.
+      e RUBY_DESCRIPTION # => "ruby 2.6.3p62
+      (2019-04-16 revision 67580) [x86_64-linux]"
+
+## Wie erhalten wir die aktuelle Methode in ruby?
+    def foo
+      cmd2('  puts "I am in #{__method__}"
+    end
+
+      require "net/ftp"; Net::FTP.method(:open).parameters
+      # => [[:req, :host], [:opt, :user], [:opt, :passwd],
+      [:opt, :acct]] (https://eval.in/180014)
+
+## Wie erhalten wir alle Konstanten im Encoding
+      namespace, in ruby?
+
+      Encoding.list
+
+      # ===================================================================== #
+      # === tap in ruby
+      # ===================================================================== #
+## Wie verwenden wir <b>.tap</b> in Ruby?
+## Wie überprüfen wir auf UTF8 Strings?
+      require "kconv"
+      "test".isutf8
+
+## Wie requiren wir <b>relativ zum aktuellen Verzeichnis</b>?
+      require_relative "../bla/eeeks.rb"
+      require_relative "../../../home/x/DATA/PC/PROGRAMMING_LANGUAGES/RUBY/src/tools/tasks.rb"
+
+      anm('Das ist erst seit Ruby 1.9 verfügbar.
+
+## Wie kann wir das <b>Encoding</b> zu BINARY setzen?
+      Encoding.default_external = 'BINARY'
+      Encoding.default_external = 'ASCII 8bit
+
+      # ===================================================================== #
+      # === Wie lese ich eine Datei ein, in ruby
+      # ===================================================================== #
+## Wie lese ich eine Datei ein, in ruby? (read self)
+      puts File.read(__FILE__)
+
+## Wie erhalten wir alle Methoden in ruby?
+    Dies geht über <b>.instance_methods</b>
+
+      # ===================================================================== #
+      # === Wie erhalten wir alle class methods und instance methods einer
+      #     Klasse
+      # ===================================================================== #
+## Wie erhalten wir alle <b>class methods</b> und alle <b>instance 
+      methods</b> einer Klasse?
+      Integer.methods # gives class methods
+      Integer.instance_methods # gives instance methods
+
+      # ===================================================================== #
+      # === How to use Autoload
+      # ===================================================================== #
+## Was ist Autoload und wie verwenden wir es?
+    autoload funktioniert ähnlich wie require, aber es lädt nur
+      Dateien wenn auf eine Konstante deiner Wahl zugegriffen wird.
+
+    Beispiel:
+
+      autoload :Daemonizable,  'thin/daemonizing'
+      autoload :Logging,       'thin/logging'
+
+    Methoden in diesem Teil werden erst ausgeführt wenn die Klasse
+      aufgerufen wird.
+
+    Man kann detektieren ob eine Klasse auf ein <b>autoload</b> wartet:
+
+      autoload :X, 'x'
+      puts 'X is awaiting loading.' if autoload?(:X)
+
+## Wie finde ich den Namen einer Methode heraus?
+      method = "cat".method(:upcase)
+      method.name # => :upcase
+
+## Was ist <b>self</b> in Ruby?
+    self ist eine read-only Variable die auf das aktuelle
+      Objekt (current object) zeigt.
+
+    Ruby braucht self um seine instance variables zu finden.
+
+## Wie lassen wir ein externes Programm in ruby laufen?',
+      'externes_programm # rf ruby externes_programm
+    def run(command, input = "")
+      cmd3("  IO.popen(command, 'r+') { |io|
+      cmd3('    io.puts input
+      cmd3("    io.close_write
+      cmd3("    return io.read
+      }
+      run 'wc -w','How many words are in this string, hmm?' # => 8\n
+
+## Wie kann ich lokale Variablen in einer Datei erstellen
+      und in einer anderen Dateien wiederverwenden?
+    Mittels:
+
+      TOPLEVEL_BINDING.eval File.read(file), 1
+
+## Wie vertausche ich 2 Variablen in Ruby? (How do i swap
+      two variables?)
+      a, b = 2, 3
+      a, b = b, a # swap here.
+
+## Was ist <b>==</b> in ruby?
+    == ist der "equality operator".
+
+    Er hat auch eine Negationsform, und zwar !=
+
+      a('http://ruby-doc.org/core/Object.html#method-i-instance_variable_defined-3F',
+        content: 'SELF
+
+## Wie finden wir heraus, ob eine instance variable definiert ist?
+    Mittels <b>.instance_variable_defined?</b>.
+
+      class Test; @foo = "hi"; end # => "hi"
+      Test.instance_variable_defined? :@foo # => true
+
+## Gibt es einen Vorteil wenn wir <b>load</b> anstelle
+      von <b>require</b> verwenden?
+    Ja. load() erlaubt es uns eine Datei neu zu laden,
+      require nicht.
+
+## Wie erhalten wir floats als Ergebnisse in ruby?
+      s2('Verwende
+    8300.0/5324
+
+      # ===================================================================== #
+      # Gets input. Mehrere Zeilen auf einmal.
+      # ===================================================================== #
+## Wie kann ein User mehrere Zeilen eintippen als input
+      zu gets? Was ist der Record Separator? (Multiline input)',
+      'user_input
+    Der Record Separator ist - $/
+
+    Es handelt sich um eine <b>predefinierte Variable</b>.
+
+    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.
+
+    Die .chomp Methode hingegen gibt einen String wieder der 
+      den Record Separator entfernt hat, ansonsten gibt es den 
+      originalen String unmodifiziert zurück.
+
+    Das eintippen von mehreren Zeilen über gets() geht indem
+      man zu $/ assigned (redefinition), bevor man gets aufruft:
+
+    $/ = "END"
+
+    Das keyword ist dann hier <b>END</b>.
+
+    Noch ein Beispiel hierzu:
+
+      "$/ = "*" # the "*" character is now the record separator
+
+    When you redefine the record separator, this new character 
+      (or string ) will now be used by methods such as gets and chomp.
+
+    For example:
+
+      $/= "world"
+      s = gets() # user enters Had we but world enough and time
+      puts s # displays Had we but world
+
+## Was ist eine <b>class method</b> in ruby?
+    Eine <b>class method</b> ist eine Methode, die unabhängig
+      von einem bestimmten Objekt aufgerufen werden kann.
+
+## Wie verhalten sich mixins?
+    mixed-in modules verhalten sich wie Superklassen.
+
+## Kann ich programmatisch eine lokale Variable erstellen?
+    Ja.
+
+      eval "t=2;t", IRB.conf[:MAIN_CONTEXT].workspace.binding
+
+## Wie bekomme ich alle Instance Variables? (get all ivars, 
+      all instance variables)
+      foo = Foo.new
+      pp foo.instance_variables
+
+## 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
+      File.open("text.txt") { |file|
+      cmd2('    file.each_line { |line| puts line }
+      } # automatically close the file here.
+
+    Wir könnten auch folgendes verwenden:
+
+      File.open(ENV["RUBY"]+"/ruby.cgi").each { |line|
+      puts line if line =~ /blue/ }
+
+    (Entferne einfach die if-clause wenn man alles
+      ausgeben möchte.)
+## Wozu dient .send?
+    Mittels .send kann man eine beliebige Methode in einem
+      Objekt aufrufen (sofern diese Methode auch <b>vorhanden</b>
+      ist. Beispiel:
+
+      e("  'your_string'.send :length # => 11'
+
+      anm('.send ist übrigens ein alias zu __send__
+
+    Man kann auch Bestimmte Attribute setzen wenn es die 
+      Klasse erlaubt. Beispiel:
+
+    d.attr=(99)
+
+    d.send(:attr=, 99) # macht das selbe wie oben, nur verboser.
+
+## Wie lese ich Daten von einer .rb Datei ohne das Ruby
+      diese Daten interpretiert?','__END__
+    p DATA.read
+    __END__
+
+    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.
+
+      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.
+
+      anm('DATA ist ein File Objekt. Man kann daher auch <b>DATA.pos</b>
+      verwenden.
+
+    Man kann mittels <b>__END__</b> auch direkt YAML Code in
+      ein .rb <b>Skript</b> einfügen.
+
+## Wie erhalte ich das Default External Ruby Encoding via
+      Commandline?
+      ruby -e 'p Encoding.default_external'
+
+## Wie verwende ich ein Objekt ohne Throwaway Variable?
+      2.times.with_object([]) { |v, o| o << v }
+
+## Wie liste ich alle Dateien im Verzeichnis?
+      pp Dir['./*']",'ls # ls tag
+
+## Was ist der $LOAD_PATH und wie erweitere ich den $LOAD_PATH 
+      um neue Pfade? (Std Path)','load_path
+    Um den LOAD_PATH zu erweitern, macht man einfach dies.
+
+      $LOAD_PATH << '/home/x/DATA/PC/PROGRAMMING_LANGUAGES/'
+
+    Nun ein paar erklärende Worte hierzu.
+
+    Der LOAD_PATH hat all jene Pfade, die Ruby durchsucht,
+      um die Ruby Standard Library zu finden. Er ist also sehr
+      wichtig.
+
+    Es gibt hier 3 konkrete Aliases die auf diesen LOAD_PATH
+      Zeigen:
+
+    $:
+    $LOAD_PATH
+    $-I
+
+    An diesen Wert kann man seine eigene Library anhängen.
+
+    Dies geht auch über die command line, und zwar mittels
+      der <b>-I flag</b>.
+
+## Wie übergebe ich einen Hash an eine Methode? Wie sammel
+      ich Argumente die ich an eine Methode übergeben möchte?
+    def foo(arg1, *rest)
+      cmd2('  puts "Got #{arg1} and #{rest.join}"
+    end
+
+      foo("one") # => Got one and
+      foo("one", "two") # => Got one and two
+      foo("one", "two", "three") # => Got one and twothree
+
+    Will man nun einen Hash an eine Methode übergeben so macht
+      man dies einfach so:
+
+      def foo(v)
+      cmd2('    pp v'  )+
+      end
+
+      foo :name => 'checkbox', :job => 'hello hello..'
+
+## Wie können wir die <b>Extension</b> einer Datei entfernen?
+      File.basename('stuff.rb', '.*')
+
+      anm('Es ginge auch mit .gsub aber das ist nicht so elegant.
+
+## Wieso verwenden wir die superclass() Methode?
+    Die superclass() Methode gibt einem die Eltern-Methode
+      wieder ("parent method").
+
+    Beispiel
+
+      puts "The superclass of Array is: #{Array.superclass}."
+
+      anm('Die Superklasse von Array ist Object.
+
+## Wie kann ich die Warnungen von Ruby ausschalten?
+      $VERBOSE = nil
+
+    $VERBOSE kann 3 Zustände haben:
+
+      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.
+
+      anm('Eine weitere Möglichkeit wäre es $stderr zu verwenden.
+
+## 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
+    Verwende hierzu <b>||=</b>
+
+      hash = { :test => "foo"}
+      your_var ||= hash[:test]
+      your_var ||= 1
+      pp your_var
+
+## 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)
+    ?a
+
+    dies würde den ASCII Code des Charakters a ausgeben.
+
+    Es gibt noch einen anderen Weg den ASCII Code zu erhalten:
+
+      "a"[0] # => 97
+
+    Specifying multiple ASCII code for several chars raises an error:
+
+    ?a
+
+    Von Nummer zu Zeichen kann man folgenden code verwenden:
+
+      "97".map { |c| c.to_i.chr }
+
+    Mittels der Methode <b>.chr</b> erhält man die Nummer.
+
+## Wie finden wir heraus ob eine Datei existiert, in ruby? (file
+      exists, file exist, dir exists, directory exists?)
+      File.exist? filename
+      File.exist? to_be_created
+
+    oder
+
+      FileTest.exists?
+      anm('Dies kann auch verwendet werden um herauszufinden ob ein
+      Verzeichnis existiert.
+
+## Wie löschen wir eine Datei in ruby (file delete, del
+      file, delete file)?
+      File.delete "testrm"
+
+## Wie erhalte ich Informationen über die Ruby Version?
+    Dies geht über die <b>RUBY_PLATFORM Konstante</b>.
+
+    Dies mag zu Problemen bei <b>Virtual Machines</b> führen.
+
+    Die Version kann man zum Beispiel wie folgt abfragen:
+
+      RUBY_VERSION == '1.8.7'
+
+## Wie kann ich verhindern das ein Objekt verändert wird
+      nachdem es erstellt wurde?
+    Verwende .freeze, wie in 
+      <span class="s1">object.freeze</span>
+
+    Versucht man ein frozen Objekt zu verändern so
+      kommt es zu folgendem Fehler:
+
+    TypeError: cant modify frozen object.
+
+    Ist ein Objekt in diesem Sinne "tainted", so kann man die
+      Methode .untaint verwenden um dieses Objekt wieder "untaint"
+      zu setzen.
+
+    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
+      # ===================================================================== #
+## Wie erhalte ich eine Referenz zu /dev/null, die möglichst
+      Plattform-unspezifisch ist?
+    Mittels <b>IO::NULL</b>
+## Wie zähle ich von 0 bis 10?
+      p(*('0'..'F'))
+
+## Wie verwende ich <b>Resolv</b>?
+      require 'resolv'
+
+      Resolv.getaddress "google.com"
+      Resolv.getaddress "google.com" # => "64.233.167.99"
+
+## What are the highest numbers for Ruby?
+    You can easily use a googol which is
+
+    googol = 10**100
+
+    You will have an error mesage if you try to output a googolplex, like
+
+    googolplex = 10**googol
+
+      frage("Wie erhalte ich die Version von Ruby
+      puts RUBY_VERSION
+
+    If you want to get the major number without
+      the minor number, use:
+
+## Wie schreibe ich direkt zu STDOUT und STDERR?
+      $stdout.puts "stdout"
+      $stderr.puts "stderr"
+
+      anm('Damit kann man dann direkt in eine Datei schreiben:
+
+      ruby stdout_stderr_test.rb > stdout 2> stderr
+
+## Wie verwende ich eine instance variable in Ruby?
+    Use
+
+    @
+
+    just before the variable, like this way
+
+    @foo
+
+      # ===================================================================== #
+      # === Wie finden wir den prefix von Ruby heraus?
+      # ===================================================================== #
+## Wie finden wir den prefix von Ruby heraus?
+      RbConfig::CONFIG['rubylibprefix'] # => \"/Programs/Ruby/2.6.3/lib/ruby\"
+
+      # ===================================================================== #
+      # === Handling permissions in Ruby
+      # ===================================================================== #
+## Wie handhaben wir <b>permissions</b> in ruby (zum
+      Beispiel überprüfen ob wir in eine Datei hineinschreiben
+      können)?
+      if File.writeable(this_file)
+
+      # ===================================================================== #
+      # === How to use "p foo".
+      # ===================================================================== #
+## Wozu verwende wir <b>p</b>, wie zum Beispiel in
+      <b>p object</b>?
+    p gibt die interne Repräsentation eines Objekts wieder
+      (<i>internal representation of an object</i>), und das ganze
+      recht detailliert.
+
+      class Foo; def initialize;@test = 5;end;end;
+      foo = Foo.new; p foo # => #<Foo:0x988c9a4 @test=5>'
+      )+
+
+      # ===================================================================== #
+      # === Wie lesen wir jedes Byte einer Datei ein?
+      # ===================================================================== #
+## Wie lesen wir jedes Byte einer Datei ein?
+    Mittels <b>.each_byte</b>:
+
+    File.open("/etc/passwd").each_byte { |byte| puts byte }
+
+    Dies kann man mit .chr übersetzen.
+
+      109.chr # => "m"
+
+      # ===================================================================== #
+      # === How to find out the name of a file in ruby
+      # ===================================================================== #
+## Wie finden wir den Namen einer Datei heraus, in
+      Ruby?
+    Mittels:
+
+    __FILE__
+
+    __FILE__ ist übrigens ein <b>Keyword</b>.
+
+## Wie erhalten wir den absoluten Pfad der aktuellen
+      Dateien?
+      Dir[Dir.pwd+'/*']
+
+## Was bedeutet ein @ vor einem Namen?
+    Dies erstellt eine instance variable.
+
+    Eine instance variable ist standardmässig nur innerhalb der Instanz 
+      der Klasse greifbar.
+
+## Wie erhalte ich eine Liste mit Prozessen von Ruby?
+      require 'sys/proctable'
+      include Sys
+
+      ProcTable.ps{ |proc_struct| p proc_struct }
+
+## Wie verwenden wir die <b>bz2 library</b> mittels ruby?
+      require 'bz2'
+      include BZ2
+
+      # ===================================================================== #
+      # === Ruby's Namespace Operator.
+      # ===================================================================== #
+## Was bedeutet <b>::Foo</b> in ruby?',':: # rfruby ::
+    Dies erstellt eine Top Namespace. Der :: ist
+      der "Namespace Resolution Operator" in Ruby.
+
+    Beispiel für die Verwendung von <b>::Foo</b>:
+
+      class Foo
+      end
+      module Bar
+      cmd2('    class A
+      cmd2('    end
+      cmd2('    p ::Foo # the top level one, not the normally scoped one
+      end
+
+## Wie beende ich ein ruby script? (ruby quit, exit program, quit
+      program)
+    Verwende "exit".
+
+    Man kann auch <b>abort</b>, mit einer Nachricht, verwenden.
+
+    Eine weitere Möglichkeit ist der at_exit handler
+      (at exit, register exit): <b>at_exit {}</b>
+
+      anm('at_exit kann oft auch verwendet werden wenn <b>END {}</b>
+      verwendet wird. Allerdings ist at_exit auch etwas mühsam.
+
+## Was bedeutet das Zeichen <b>^</b>?
+    Dies meint this-or, auch als <b>xor</b> bekannt. Man kann
+      damit conditionals testen, also ob eine Variable true oder
+      false ist.
+
+## Wie überprüfe ich die Klasse eines Objektes?','type_checking
+      a.is_a? String
+      5.is_a? Integer # => true
+
+      # ===================================================================== #
+      # === Target platform of the OS
+      # ===================================================================== #
+## Wie finde ich die Target Platform des OS heraus, unter ruby?
+    Verwende <b>RUBY_PLATFORM</b>
+
+    Beispiel:
+
+      puts RUBY_PLATFORM
+
+## How can I make Ruby Objects persisting/surviving?
+    There are some solutions like storing in a yaml file, using
+      madeleine, Object Graph or hibernate, or marshalling.
+
+    <a href="http://www.rubygarden.com/index.cgi/Libraries/og_tutorial.rdoc">
+      Object Graph </a>
+
+## Gibt es etwas zu require zu sagen?','require # require tag
+    Die Dateien die bei <b>require</b> verwendet werden im 
+      Array <b>$"</b> gespeichert - also noch besser gleich 
+      <b>$LOADED_FEATURES</b> verwenden.
+
+    Man kann - bequemerweise - global Variables und Methoden 
+      tracen. <b>Beispiel</b>:
+
+      trace_var :$x, proc {print "The global variable $x 
+      is now ", $x, "\n"}; $x = 8 # => The global variable $x is now 8
+      $x=10
+      anm('Dies würde sich doch hervorragend für Events eignen. Leider
+      funktioniert trace_vor nur mit Globalen Variablen.
+
+      anm('Man kann eine getracedte Variable auch wieder untracen:
+
+      untrace_var :symbol
+
+## Wie erhalte ich den PATH_SEPARATOR?
+      File::PATH_SEPARATOR
+
+## Wie verwenden wir echten Parallelismus in Ruby?
+    Wir können <b>Process</b> verwenden.
+
+## Wie erhalten wir programmatisch die Klasse einer Methode?
+      method(:function_name).class
+      method(:function_name).object_id
+
+## Was meinen wir mit einem <b>Quine</b>?
+    Ein quine ist hier eine Datei, die ihren eigenen Quellcode
+      (== source code) ausgibt.
+
+## Wie kann ich Methoden miteinander verknüpfen (chainen, method chaining)?
+    Zum Beispiel via:
+
+    array.flatten.uniq
+
+    Hier ein einfaches, obgleich seltsames, Beispiel:
+      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
+      end # outhello
+    outhello
+
+## Was ist STDOUT und STDOUT.flush?
+    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).
+
+    STDOUT.flush wiederum stellt sicher, das das Terminal seinen
+      Buffer entleert, also wieder auf "leer" zurückgesetzt wird.
+
+    Anders formuliert - was auch immer im buffer war, wird 
+      ausgegeben.
+
+    Normally, the input is buffered line by line until it finds 
+      a newline ( \n )
+
+    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.
+
+    You can use puts instead of course.
+
+    An alternative to STDOUT.flush you could try this:
+
+      STDOUT.sync = true
+      print "Processing... "
+
+      frage("Wo ist die Online Version von IRB?
+      a('http://tryruby.hobix.com/', content: 'http://tryruby.hobix.com/
+## Wer ist der Ruby Held?','hero
+      img('PROGRAMMING_LANGUAGES/RUBY/MATZ_IS_MY_HERO.png',
+          'marl1em','ruby_held
+
+
+      div {
+      The error will be stored in <b>$?</b>.
+  
+      Du kannst auch die PID davon erhalten, zbsp:
+  
+        `ls`; puts $?.pid; puts $?.exitstatus
+  
+      You can also use another syntax, for example:
+  
+        %x{ echo "$CD"}.chomp
+  
+      system() does not capture output, so you cant use variables
+        within system which get calculated only the moment they exist,
+        like ENV["home"].
+  
+      To work with it, you must assign a variable to it.
+  
+      Alternatively you can use something like instead:
+  
+      `#{MAIN_COMMAND} 2>&1`
+      `make 2>&1`
+        $?.exitstatus
+        $CHILD_STATUS.exitstatus'
+        )+
+  
+      Alternativ kann man <b>popen</b> verwenden, siehe hierzu
+        mein <a href="#stdin">stdin Beispiel</a>.
+  
+      Wie vermeiden wir bestimmte Warnings?
+  
+        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 {
+  ## 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'
+        )+
+  
+      Beispiel hierzu:
+  
+        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
+
+
+
+## Wie verwenden wir english/roman?
+
+        require 'english/roman'")+
+                 100.to_roman # => "C"
+         9.to_roman   # => "IX"
+      Dokumentation sehen wir auf:
+        a('https://rubygems.org/gems/english/versions/0.6.3')
+      
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+## Wie verwende ich den ternären : operator um zu bestimmen 
+      was ich verwenden sollte?','ternary
+    See below for the ternary operator
+
+      x = 5 < 4 ? 'hi' : 'bye'
+
+
+
+## Wie mache ich Conditionals in Ruby?
+      if city == "Toronto"
+       drinking_age = 19
+      else
+        drinking_age = 21
+      end
+
+      h2('Conditionals in Ruby','s1em pad5px mar5px','',
+         'border-bottom:1px solid royalblue
+      table2('s1em mar2px bblack1 marl2em','_',
+        'TableRubyModeStrings',
+        '==','equal',
+        '!=','not equal to',
+        '>','greater than',
+        '<','less than',
+        '>=','greater than or equal to',
+        '<=','less than or equal to'
+      )
+    }
+