public void testCreatingAContact() throws Exception {
Window window = getMainWindow();
//For now we use getMethods from the original JFrame class
MyJFrame pd = (MyJFrame) window.getAwtContainer();
//uispec4j uses wrappers for swing components
ListBox lb = new ListBox(pd.getJList()); // or new JList()

assertTrue(lb.isEmpty());

Button add = new Button(pd.getButton());

add.click();

ComboBox box=new ComboBox(pd.getCombo());

String[] inhaltListe=new String[]{”001″};

assertTrue(lb.contentEquals(inhaltListe));
}

protected void setUp() throws Exception {
setAdapter(new MainClassAdapter(MyJFrame.class, new String[0]));
}

}

“London Schule” legt den Schwerpunkt eher auf Rollen , Verantwortlichkeiten und Interaktionen

Nachrichtenaustausch anstatt Anwendung von Algorithmen

ref

Non Breaking Error Handling

Begriffe:
Applicativer Functor
Semigruppe

Applicativer Functor–
M[A] => M[A => B] => M[B]

typ transformation durch Anwendung, bsp. map

Semigruppe
binär assoziative Operation
für das Beispiel wir deine ListSemigruppe benötigt
assoziativ: +, * , List.append, - nicht!?!
distributiv
kommutativ

impl ohne implicit:
sealed trait Validation[E, X]{

def map[Y](f: X => Y): Validation[E, Y]
= this match {
case Failure(e) => Failure(e)
case Success(x) => Success(f(x))
}

def <<*>>[Y](f: Validation[E, X => Y],s: Semigroup[E]): Validation[E, Y]
= (this, f) match {
case (Failure(e1), Failure(e2)) => Failure(s append (e1, e2))
case (Failure(e1), Success(_)) => Failure(e1)
case (Success(_), Failure(e2)) => Failure(e2)
case (Success(x), Success(k)) => Success(k(x))
}

}

final case class Failure[E, X](e: E) extends Validation[E, X]
final case class Success[E, X](x: X) extends Validation[E, X]

case class Person(age: Int, name: String, postcode: String)

trait Semigroup[A] {
def append(a1: A, a2: A): A
}

class ListSemigroup[A] extends Semigroup[List[A]] { def append(a1:List[A],a2:List[A]) = a1 ::: a2 }

object Validator{

def validAge(i: Int): Validation[List[String], Int] = if(i < 0) Failure(List("Age must be greater than 0")) else Success(i)

def validName(s: String): Validation[List[String], String] = if(s == "Klaus") Success(s) else Failure(List("nur Klausn"))

def validPostcode(s: String): Validation[List[String], String] = Success(s)

def main(args: Array[String]) {
if(args.length < 3)
println("Need at least three arguments")
else {
val f = (Person(_, _, _)).curried

val age = validAge(args(0).toInt)
val name = validName(args(1))
val postcode = validPostcode(args(2))

val semi: Semigroup[List[String]] = new ListSemigroup[String]()

val step1 = age map f
val step2 = name <<*>>(step1,semi)
val stepr = postcode <<*>>(step2,semi)

stepr match {
case Success(p) => println(”We have a person: ” + p)
case Failure(e) => e foreach println
}
}
}

}

Metzger ist lustig, gut designt

==04==
l.foldLeft(0) {(a,b) => a+1 }

==05==
def myRev[A](l:List[A]):List[A] = l.foldLeft([List[A]()) { (a,c) => c :: a}

===14==
l.foldLeft(Nil.asInstanceOf[List[Int]]) {(c,a) => (a :: a :: c) }

==15==
def consmore (l:List[Int], count:Int, element:Int):List[Int] = if(count==0) l else consmore(element::l,count-1, element)

==28==
ll=List[List[Int]] = List(List(1, 2), List(1, 2, 3), List(4, 5), List(5), List(3, 4, 5), List(7), List(1, 2, 3, 4, 5), List(1, 2, 3, 4))
val r1=ll.foldLeft(List[(Int,Int)]()) { (a,b) => (b.length,ll indexOf b) :: a}
val r2= r1 sortWith ((t1,t2)=> t1._1 > t2._1)
val finalResult=r2.foldLeft(List[List[Int]]()) { (a,b) => ll(b._2) :: a }

==50==
class Knoten(val h:Int, val zeichen:Char){
def this(h:Int) = this(h,’1′);
private var kante:Knoten = null
private var kantenWert: Int = -1
def getKante() = kante
def setKante(k:Knoten, kw: Int) = {kante = k; kantenWert = kw}
def hasKante() = kante != null
def isLeaf() = !zeichen.isDigit
def getCode() = kantenWert
override def toString() = h+” kante:”+nn(kante)
def nn(k:Knoten) = if (k == null) “” else k.h
}

import scala.collection.mutable.HashMap

def findFreq(s:String):HashMap[Char,Int] = {
val r=new HashMap[Char,Int];
s.distinct.foreach(x=> r+= (x -> (s count(y => y==x)) ) );
r
}

val list1=((for {b <- fr; fre =b._2; element=b._1 } yield new Knoten(fre,element)).toList) sortWith (sortKnoten)

def transform(l:List[Knoten]):List[Knoten] = {
val step=l filter(! _.hasKante) take 2
if(step.size > 1){
val k=new Knoten(step(0).h+step(1).h)
step(0).setKante(k,0);
step(1).setKante(k,1);
transform(((k::l) sortWith (sortKnoten)))
}else
l
}

def getP(c:Knoten, fillMe:String):String = {
if(c.getCode!= -1) //Wurzel
getP(c.getKante, fillMe+c.getCode.toString)
else
fillMe.reverse
}

val resAnzeige=(list1a filter (_.isLeaf) map(x => x.zeichen+”:”+getP(x,”") ))

Das Verfahren konstruiert einen binären Baum mit einer Knoten¬markierung p und einer Kanten-markierung h.

Algorithmus Huffman
Eingabe: Text t
Ausgabe: Binärer Baum mit einer Knoten¬markierung p und einer Kanten¬markierung h
Methode:
1. erzeuge für jedes Zeichen x, das im zu codierenden Text t vorkommt, einen Knoten und markiere den
Knoten mit der Häufigkeit, mit der x im Text vorkommt;

2. wiederhole solange es mehr als einen Knoten gibt, zu dem keine Kante hinführt
a. suche zwei Knoten u und v mit minimaler Markierung p(u) bzw. p(v), zu denen noch keine Kante hinführt;
b. erzeuge einen neuen Knoten w und verbinde w mit u und v. Markiere die eine Kante mit 0, die andere mit 1. Markiere den Knoten w mit p(u) + p(v);

Nach Konstruktion dieses Baumes ergibt sich für jedes Zeichen x die Codierung c(x) als Folge der Kanten¬markierungen auf
dem Pfad von der Wurzel zu dem Blatt, das zu x gehört.

          11
         /    \
       /        7
     /      /    \
   /     3        \
 /      / \        \
4   1   2      4
I      M    P       S

link1
link2
ref
P50

Funktor
Applikativer Funktor ref
Monoid ref
Monad
Halbgruppe ref

Vererbung funktioniert nicht (gut?!) mit Funktionaler Programmierung.

Wenn man sich erst einmal an den etwas seltsamen Erzählstil der Beiden gewöhnt hat gibt es schon einige interessante Sachen zu bemerken.
Das zusammen leben und erleben am Beispiel einer Geburtstagsparty zum Beispiel. Bei der als Höhepunkt des Abends das gemeinschaftliche Spielen an der XBox angeprangert wird (S.45). Sind Partys verwerflich auf denen “Erwachsene” Videospiele spielen? Ich denke nicht und jeder muss dann für sich selbst die Frage beantworten inwiefern so ein Abend für ihn unterhaltsam ist. Schließlich spielt man ja nicht den ganzen Abend, das wäre ja langweilig.
Im folgenden wird ein erstaunliches Phänomen betrachtet Cocooning. Für mich war es deswegen erstaunlich weil ich Teilaspekte dieses Verhaltens bereits des öfteren in meinem Umfeld bemerkte. Wenn die unterschiedlichen Symptome aber zusammengefasst und benannt werden wirkt das schon etwas bestürzend. Auf einmal ist sie da, die Kategorie, die Schublade und nun was bzw. wie viel will man nun hinein stopfen?

->Interesselosigkeit am Partner artet in Bequemlichkeit aus
->Brettspiele schaffen Geselligkeit, was schafft WOW?
->Peter Wipperman : “Es wird Gebiete geben auf denen man Kompetenz einbüßt. Dafür wird man in anderen Bereichen neues Wissen aufbauen”
->Fazit?