Auf http://de.wikipedia.org/wiki/Barrierefreies_Internet findet sich
ein Link zu einer "Verordnung zur Schaffung barrierefreier
Informationstechnik nach dem Behindertengleichstellungsgesetz
(Barrierefreie Informationstechnik-Verordnung - BITV)".
Hier findet sich dann auch eine Auflistung der Bedingungen, die an
einen barrierefreien Auftritt gestellt werden:
wie sieht es mit windows anwendungen aus? geht das genau so komfortabel wie mit c++?
Wenn sich die Frage auf das Zusammenklicken von graphischen Oberflaechen mit einem Tool bezieht dann ist die Antwort nein. Es gibt schon GUI Editoren fuer Java, aber Ich kenne keinen der so gut funktionert wie der vom Visual Studio. Wenn dir das wichtig ist (es geht auch gut ohne), dann empfehle ich dir doch lieber mit C# zu arbeiten als mit Java. Bei C# arbeitest Du mit dem Visual Studio. Und die Bibliotheken die Du fuer Deine Zwecke brauchst
findest Du fuer beide Platformen.
Wenn sich deine Frage auf den Code selber bezieht, dann ist die Antwort Ja. Sowohl in C# als auch in Java findest Du das Erstellen von GUI Anwendungen vermutlich viel einfacher als in C++.
wie sieht es mit compilern aus? habe bis her nur etwas von dos-fenster compiler gelesen?
Auch in C++ sind so gut wie alle compiler "dos-fenster compiler". Was nicht bedeutet das Du nicht ein graphisches "Windowsprogramm" verwenden kannst, das den Compiliervorgang fuer dich aufruft. Das Visual Studio macht das so, und die Java IDE's ( z.b. eclipse.org ) koennen das
auch.
Evntuell moechtest Du hier auch hineinschauen: http://www.informatik-forum.at/showthread.php?t=56323
Ich will mit einem maschinellen Lernalgorithmus Koordinaten (x und y Wert) vorhersagen.
Zu dem Zweck hab ich mir WEKA angesehen, dass unterstützt aber leider nur die Vorhersage einer Variable.
Kennt jemand ein Tool/API, das mir zwei Variablen vorhersagen kann und wo ich dann den trainierten Algorithmus aus Java heraus verwenden kann?
Oder wie kann ich das Problem sonst lösen?
Du koenntest vielleicht das Trainingsset einfach zweimal durchlaufen und dann die
Ergebnisse vergleichen?
Also ich habe z.B gerade aus diesem Trainingsset
@relation 'signalstaerke'
@attribute 'station1' real
@attribute 'station2' real
@attribute 'station3' real
@attribute 'X' real
@attribute 'Y' real
@data
40,30,100,10,20
10,13,90,70,50
33,32,77,70,70
23,44,75,20,30
34,21,23,70,87
40,22,10,16,20
41,11,100,15,20in Weka mit Linearer Regression jeweils zwei Formeln rausgefischt:
X =
-0.7733 * station1 +
0.9012 * Y +
24.8939
und
Y =
0.6987 * station1 +
0.9916 * X +
-18.0198Wenn Du die beiden Funktionen gleichsetzt, hast Du eine Prognose fuer
beide Werte (die in diesem Fall natuerlich Bloedsinn ist, wegen des
kleinen Datensets und der zufaellig gewaehlten Daten). Wenn das
Datenset sehr gross ist und du einen sehr komplexen Algorithmus
verwendest, wirst Du das Trainingsset halt eventuell aufspalten muessen,
wegen Performance.
Wikipedia hat eine recht gute Erklaehrung zu Design Patterns in der
Software Entwicklung: http://en.wikipedia.org/wiki/Design_pa…mputer_science) .
Du hast aber gesagt, man sollte über
Observer lesen, bevor man mit Java GUIs programmiert, no? Ist die
Beschreibung des Observer im GOF-Buch so mies?
Ja. Das GoF ist ein guter Pattern Katalog aber eine sehr schlechte
Einfuehrung in Design Patterns. In dem Buch das ich empfohlen hatte
(Head First Design Patterns) werden die Patterns ausgiebig erklaehrt
und diskutiert (auf eine etwas kindliche Weise muss man dazu
sagen). HFDP verschlingt ein Programmierer mit Grundkentnissen + ein
wenig OOP in unter einer Woche. Und es macht auch noch Spass.
Abstraktion ist ein Werkzeug. Abstraktion
kann zu high-level sein, wenn sie einem ohne Anwendungsbezug top-down
eingetrichtert wird. (Hallo Mathe-LVAs.)
Wenn einem eine Abstraktion "ohne Anwendungsbezug top-down
eingetrichtert wird", das macht sie das nicht 'zu high level', sondern
die Abstraktion wird einfach nur schlecht erklaehrt. In HFDP wird
z.B. das Observer Pattern (unter anderem) anhand von Swing Events
diskutiert.
Abstraktion ist nicht etwas schlechtes, nur weil sie Detailkenntnisse
nicht gleichermassen unbedeutend macht.
muß ich das als Newbie gleich
wissen? Das lenkt mich doch nur von meinem konkreten Problem ab, mal
irgendeine Reaktion auf irgendeine Aktion zu kriegen.)
Ich hab doch gar nicht gesagt das man Patterns als erstes Lernen
sollte. Zu dem Zeitpunkt, an dem ich ein Pattern Buch empfohlen habe,
hat man nach meinem vorgeschlagenen Plan bereits mind. 2 Buecher
gelesen und kann bereits alle moeglichen praktischen Programme
schreiben.
Die Frage war ob man Swing bereits in seinem Erstlingswerk lernen
sollte. Swing ist nun wirklich keine besonders wichtige
Bibliothek. Ich habe sie (abgesehen fuer Antworten hier im Forum)
seit Jahren nicht mehr verwendet.
Gleich das zweite Buch auf meiner Liste (K&R in Phase II) enthaelt den
Code von zahlreichen Programmen, die offensichtlich sehr nuetzlich
sind, zumindest werden sie jeden Tag millionenfach benutzt. Der
Studierende kann solche Programme bereits nach dem ersten Buch auf
meiner Liste schreiben. Noch ganz ohne Design Patterns.
(Hast du jeden Morgen eine andere
Kaffeemaschine?)
Ich muss eine ganze Reihe von Dingen machen bevor ich meinen Kaffee
habe. Die abstrahiere ich allesamt zu einem einzigen Begriff. Ich
denke mir "Ich moechte jetzt einen Kaffee machen", nicht "Ich moechte
in die Kueche gehen, meinen Wasserbehaelter auffuellen, die Maschine
starten ...".
Gar nicht. Du blendest aus, daß die Leute auch ohne Patterns-Bücher
irgendwie über die Runden gekommen sind.
Die Frage ist ob sie mit dem Konzept Design Patterns besser ueber die
Runden kommen. 'Irgendwie' sind wir auch mal ohne Feuer ausgekommen.
Die Frage ist ob es was nuetzt wenn manche Menschen Patterns aus dem
Code raussuchen und sie Katalogisieren. Du bist offenbar der Meinung
das ist nicht der Fall, ich sage es ist extrem hilfreich. Zum
Verstaendnis von Softwaredesign und vor allem zur Kommunikation.
Vielleicht bin ich ja einfach nur viel dümmer als der
durchschnittliche Java-Programmierer, aber ich finde "du gibst eine
Callback-Funktion an, die aufgerufen wird, wenn dieser Button geclickt
wurde--weil James Gosling eine Gurke ist, mußt du die Funktion in eine
anonyme Klasse ohne sonstigen Sinn verpacken, sorry" ...
Vielleicht bist Du ja auch viel viel klueger? Die meisten Einsteiger
haetten mit deiner Erklaehrung z.B. einige Probleme:
- Was ist eine Callback-Funktion?
- Wo in meinem Code gebe ich diese Callback-Funktion an?
- Wo in meinem Code rufe ich diese Funtion auf?
- Wer ist James Gosling und warum ist der eine Gurke?
- Was ist eine anonyme Klasse?
Dann gibt es Punkte die Du ueberhauopt nicht erklaehrt hast:
- Warum macht man das denn ueberhaupt so?
- Wann koennte ich das auch so machen wollen?
- Wann sollte ich es besser bleiben lassen?
Ein Buch ueber Design Patterns ist nichts weiter als deine
Erklaehrung, aber hoffentlich mit weniger Bashing und mehr
Information.
...bevor er sein erstes Java-GUI schreiben
darf, muß er erstmal einige Kapitel im GOF-Buch lesen.
Das GOF Buch habe ich nicht empfohlen. Ich finde es ist ein gutes
Buch, aber ich habe es bei meinen Einsteigerbuechern nicht
erwaehnt. Das man es lesen sollte bevor man sich mit Java GUIs
auseinandersetzt hab ich schon gar nicht gesagt.
Für mich gibt es bei Iteratoren schon Muster: In C++ ist das Muster,
daß ich für jeden Container ein-zwei Zeilen boilerplate code schreibe,
was normalerweise zwar verpönt ist, aber wenn der boilerplate code
nicht boilerplate code heißt, sondern Pattern (die Benennung ändert
nämlich wahnsinnig viel daran, daß sich ständig der gleiche Code
wiederholt), dann darf ich das und werde sogar für die Eleganz meines
Codes gelobt; Teil des Musters ist auch, daß ich mich für jede
einzelne Iteration ein wenig gräme.In Smalltalk ist das Muster, daß ich do: schreibe und mit meinem
Programm fortfahren kann, während andere Leute sich noch den Kopf
zerbrechen, wie sie hier am besten das Iterator-Pattern instanziieren.
Du beschreibst hier zwei Implementierungen eines Patterns und bemerkst
(voellig korrekt), das eine der beiden Varianten einfacher ist als die
zweite. Was hat das damit zu tun ob man etwas ueber das Pattern
selber wissen sollte? Fuer mich klingt das eher danach das Du
Iteratoren nicht gerne in C++ implementierst.
Der Name ist do: . Der Name ist map. Der Name ist mapcar und
Konsorten.
Alles Namen von konkreten Implementierungen, und keiner davon nur fuer
die Implementierung eines Iterators zu gebrauchen. Ein Iterator ist
ein Pattern der eine bestimmte Form von Kommunikation zwischen zwei
Objekten beschreibt. Wenn ich Kollegen vorschlage irgendwo in einem
Design einen Iterator zu verwenden, dann haben die ein genaues Bild
davon wie die Schnittstellen aussehen.
Namen vergibt man um zu abstrahieren und zur Kommunikation.
Du selbst machst das auch, ueber dein ganzes Posting verteilt.
Du sprichst z.B. von 'callbacks' und gehst davon aus das ich
weiss was du damit meinst. Ueberleg mal wie praktisch es ist
dass ich mir etwas darunter vorstellen kann.
Ich glaube ein Teil meines großen Problems
mit zu überzeugten Pattern-Anhängern ist, daß sie zu glauben scheinen,
Leute wären zu blöd, um quasi bottom-up Muster zu erkennen, deswegen
muß man sie ihnen von einem total hohen abstrakten Niveau ausgehend
top-down eintrichtern. Spätestens nach der dritten Swing-Komponente
sehe ich, daß sie wohl alle mit dem gleichen Callback-Mechanismus
ausgestattet sind, und bin damit sowohl zeitlich als auch in der
praktischen Erkenntnis dem Heini voraus, dem man gesagt hatte,
Abstraktion ist gut. Wenn ich ein Problem allgemein Beschreiben kann,
dann kann ich es besser erkennen wenn ich es antreffe.
Abstraktion ist der Grund weshalb wir komplexe Probleme ueberhaupt
beaeltigen koennen. Abstraktion macht es moeglich das ich mir morgens
Kafee machen kann, ohne jedes mal die einzelnen Schritte durchzugehen,
die dafuer notwendig sind.
Wenn ich ein Buch ueber Softwareentwicklung schreiben wuerde, dann
ginge es im ersten Kapitel ueber die Bedeutung von Abstraktion. Die
Authoren von 'Structure and Interpretation of Computer Programs' haben
das verstanden. Leider ist das Buch sonst nicht ganz so
einsteigerfreundlich, sonst haette ich es gleich als erstes empfohlen.
und immer schön brav multiplies, bind2nd
und project1st verwenden, weil der Bjarne leider auch falsche
Prioritäten gesetzt hat.
*Klatsch Klatsch!* Bleib doch bitte bei uns! was hat denn jetzt
Stroustrup mit unserer Pattern Diskussion zu tun?
Was kümmert mich, ob GOF Jahrzehnte nach der ersten
Implementierung von Lisp einen tausendsten Namen erfunden haben? Das
Konzept war vor ihnen da und allgemein bekannt.
Was kuemmert es mich wer als erster da war? Hier werden ja keine
Pokale verteilt. Im uebrigen behauptet die GOF nicht, die Patterns in
ihrem Buch erfunden zu haben.
[tex='n'][/tex]
Ja. Ich muß auch wissen, wie ich in meinen Graphen meine Methoden
aufrufe. Und ich weiß es, ohne darüber Bücher zu lesen oder zu
schreiben. Es sagt hier keiner, daß man nicht verstehen soll, was man
tut. Im Gegenteil, ich bin sehr dafür, daß man versteht was man
tut, anstatt krampfhaft zu versuchen, seinem Anwendungsgebiet Kapitel
soundso des-ten Pattern-Buchs überstülpen zu wollen.
Du brauchst also gar keine Buecher zum lernen? Du tippst einfach drauf
los und alles andere kommt von selbst? Das bestaetigt meine Theorie von
oben, das Du einfach viel klueger bist als der Rest von uns: Ich habe
z.B. sehr viel lesen und lernen muessen, bis ich Vererbung
einigermassen verstanden habe. Und was es ueber Methoden alles zu
wissen gibt finde ich auch alles andere als offensichtlich.
Woher weisst du das du etwas wirklich verstanden hast? Ich muss jedes
Jahr ueber mein naives Ich aus dem Vorjahr laechelen. Vielleicht wird
es Dir naechstes jahr ja auch so gehen?
(Ja, ich habe Swing-Applikationen
entwickelt, nein, ich habe es dabei nie nötig gehabt, über "Observer"
nachzudenken; event handler ist übrigens ein tausendmal besserer
Ausdruck im Bezug auf Swing.)
Ich habe nicht behauptet man koennte es nicht anders lernen. Ich sage
nur das es der laengere und schwierigere Weg ist. Swing verwendet
Observer nunmal sehr viel. Wenn ich das Pattern kenne, verstehe ich
die Motivation und Funktionsweise leichter. Wenn ich eh beides
irgendwann lernen muss, dann mach ich das doch am besten aufbauend?
Generell haben viele der hochgelobten Patterns nichts mit Design von
Softwaresystemen zu tun, sondern sind nur Artefakte davon, daß Leute
minderwertige Sprachen wie Java verwenden.
Auch hier muss ich dir wiedersprechen: Auch wenn Du nur in den (sehr
seltenen) Genuss kommst, ausschliesslich sehr abstrakte Sprachen
verwenden zu duerfen ('minderwertig'/'hochwertig' passt hier nicht
finde ich), ist es wichtig sich mit Patterns auszukennen. Auch wenn
ein Pattern in einer Sprache integriert ist, verschwindet es meistens
nicht, sondern es bleiben die meisten Eigenschaften eines Patterns
(Kontext, Motivation, Konsequenzen usw.) immer noch relevant. Nur
wenige verschwinden wirklich in abtrakteren Programmiersprachen. Was
wegfaellt ist nur die Implementierung.
Ist Iterator noch ein Pattern, wenn es in die Sprache integriert ist
(z.b. smalltalk)? Streng genommen vermutlich nicht. Aber deswegen ist
es immer noch wichtig, dass ich die Notwendigkeit fuer einen Iterator
in einer Problemstellung erkennen und ihm einen Namen geben kann.
Oder ein anderes Beispiel: Vererbung ist fuer einen Java programmierer
kein Design Pattern mehr. Trotzdem muss ein Java Programmierer aber
noch wissen was Vererbung ist und wie man sie anwendet.
ich empfehle java ist auch eine insel (openbook). gibt eine tolle einführung und einen überblick über die sprache. behandelt sogar corba/rmi
Ich empfehle dieses Buch ausdruecklich _nicht_. :
1.) Das Buch konzentriert sich viel zu sehr auf das Erlernen einer konkreten Programmiersprache (in diesem Fall Java) und zu wenig aufs Programmieren. Geschichte von Java, Motivation von Java, Syntax von Java,... All das ist gut zu wissen, aber sicher nicht wenn man anfangt zu programmieren. In dem Buch steht ausguehrlich beschrieben welche Zeichen in einem Indetifier stehen duerfen, aber wie und wozu man einen Identifier eigentlich benutzt wird kaum und nur sehr unzureichend erwaehnt.
2.) Ungefaehr 2/3 des Buches befassen sich mit Bibliotheken aus der Java Standardbibliothek. Eine Bibliothek zu erlernen, die man spaeter vielleicht niemals verwendet, anstatt die Grundlagen zu erlernen, die man zum Programmieren benoetigt? Die meisten Bibliotheken sind zudem viel schneller zu erlernen, wenn man sich erstmal mit Datenstrukturen und Designpatterns auskennt: Swing lernen vor dem Observer Pattern? JavaStreams lernen vor dem Decorator Pattern? Corba lernen in Phase I ? CORBA?? Ich glaube nicht das das klug ist.
3.) Java ist nicht unbedingt die beste Wahl fuer eine erste Programmiersprache : Java ist relativ low-level und es gibt in Java so viele Syntaxeigenheiten die man lernen (oder noch schlimmer: Ignorieren) muss, bevor man sich auf das Programmieren selber konzentrieren kann. Wer sich mit Java auseinandersetzen will, dem empfehle ich Bruce Eckels "Thinking In Java". Aber erst in Phase III.
Fuer mich klingt das Buch nach Lernen in Slow Motion.
Hallo Marco!
HTML ist eine Markup Sprache, d.h. Du kannst damit etwas am Computer (meistens innerhalb deines Webbrowsers) darstellen, aber Du kannst nichts berechnen. HTML wird meistens in Verbindung mit anderen Programmiersprachen verwendet, die etwas erzeugen. Das Ergebnis kann dann (unter anderem) in HTML dargestellt werden.
Wenn Du mit dem Programmieren beginnst, wirst Du eher eine 'richtige' Programmiersprache lernen wollen. HTML kommt dann so nebenbei.
C ist da ein guter Kandidat, noch besser ist es meiner Meinung nach Du faengst mit einer Sprache wie Python oder LISP an. Ich glaube es ist am besten erst mit einer high-level Sprache anzufangen (z.B. Python oder Ruby oder Lisp oder ...), dann das K&R Buch zu lesen (Einfuehrung in C, siehe unten), und dann die fortgeschrittenen Techniken zu erlernen.
Viel wichtiger als mit welcher Programmiersprache du anfaengst ist aber, welche Literatur Du liest und WIE Du lernst. Zwar gibt es zwischen den einzelnen Programmiersprachen grosse Unterschiede: Aber bevor Du Dich mit denen auseinandersetzt (Du wirst eh mehrere Sprachen lernen muessen/wollen), musst Du erstmal das Programmieren ganz allgemein lernen. Am wichtigsten ist es dabei das Du dich auf die Algorithmen, Strukturen usw. konzentrieren kannst und das Du sehr schnell Ergebnisse zu sehen bekommst.
Was Du am besten machst:
* Theorie lesen
* Code anschauen
* Code schreiben
* ueber Code diskutieren.
Alles ungefaehr gleich intensiv.
Am Anfang deckt ein Lehrbuch meistens eh alles (zumindest die ersten drei) ganz gut ab, weil es in einem guten Buch viel Beispielcode und Uebungsaufgaben geben sollte. Du musst dann halt auch wirklich die Uebungen live am Rechner ausprobieren und damit herumspielen. Also nicht lesen und davon ausgehen das Du alles verstanden hast.
Wenn Du etwas Erfahrung gesammelt hast musst du dann (neben weiteren Buechern) immer wieder in die Programmierprojekte von anderen reinschauen (Die Open Source Kultur ist da ein Geschenk des Himmels), und natuerlich Deine eigenen Programme schreiben.
Buchempfehlungen
Phase I: Noch gar keine Programmiererfahrung (eines auswahelen):
How To Think Like An Computer Scientist http://www.ibiblio.org/obp/thinkCSpy/
Head First Java http://www.amazon.de/Head-First-Java/dp/0596009208
Phase II: Maschinennahe programmierung:
The C Programming Language (K&R) http://en.wikipedia.org/wiki/K%26R
Phase III (alle lesen):
The Pragmatic Programmer. From Journeyman to Master http://www.amazon.com/Pragmatic-Prog…r/dp/020161622X
Structure and Interpretation of Computer Programs http://mitpress.mit.edu/sicp/full-text/book/book.html (wird am MIT als Phase I buch verwendet, gehoert aber eher hier hinein.)
Code Complete (2nd Edition) http://www.amazon.com/Code-Complete-…l/dp/0735619670
The Algorithm Design Manual http://www2.toki.or.id/book/AlgDesignManual/
Head First Design Patterns http://www.amazon.com/Head-First-Des…s/dp/0596007124
Refactoring: Improving the Design of Existing Code http://www.amazon.com/Refactoring-Im…e/dp/0201485672
Test Driven Development http://www.amazon.com/Test-Driven-De…e/dp/0321146530
Es gibt noch viele andere gute Buecher die man unbedingt lesen sollte die mir aber grad nicht einfallen. nach Phase drei kennst du dich Da aber eh selbst gut genug aus um zu wissen wie Du weitermachst.
Phase IV ist dann Spezialisierung, d.h. Du weisst zu dem Zeitpunkt z.B. das Du dich fuer Artificial Intelligence interressierst und moechtest Dir dieses buch kaufen:
http://www.amazon.com/Artificial-Int…d/dp/0137903952
Falls Du (wie ich) lieber aus einem Buch lernst das man aufklappen kann: Alle Buecher bei denen ich auf eine online Version verlinkt habe gibt es auch als Hardcopy.
Zum Schluss noch ein Klassiker:
versuche mal statt '\n' die Zeichenfolge '%0D' zu ersetzen. Das ist das HTML encoding fuer carriage return
Du kannst die einzelnen Zeichen nachschauen hier und auch damit herum experimentieren.
Ajax erfordert Get
Nein. http://www.xul.fr/en-xml-ajax.html#ajax-post.
Was Du da machst, also AJAX Grundlagen lernen, ist natuerlich zu Uebungszwecken und Verstaendnis klasse und sinnvoll.
Aber was Du vielleicht nicht weisst: Fuer den Praxisfall gibt es mittlerweile sehr starke Bibliotheken, die dich von diesem
low-level "request zusammenbauen" befreien. Z.B. prototype.js ist sehr populaer.
Ich kenne mich mit PDO nicht aus, aber ich habe mal "PHP bindparam PDO"
bei Google nachgeschlagen und bin auf diese Seite im Manual gestossen. Auf der sieht ein Aufruf
auf bindparam() anders aus als bei Dir.
Bist du sicher das es nicht
$dbQuery->bindParam(':name', 'admin', PDO::PARAM_STR);
heissen muss?
Wer kennt das nicht.. Spätestens nach einem halben Jahr muss man sein XP neu installieren weils ewig zum Starten braucht und alles zugemüllt ist.
Ich fand diese Fruehjahrsinstallation (ich hab das immer 1/Jahr gemacht)
immer ganz nuetzlich und eigentlich gar nicht soo unangenehm: Einmal alles
neu installieren, da merkt man dann auch was man wirklich an Software braucht.
Ausserdem ist man so gezwungen, zumindest einmal im Jahr ein Backup zu machen.
also Leute ich bin doch etwas geschockt.
wenigstens nen Link zu den java Tutorials hättet ihr machn können.
Wirfst Du mir da jetzt vor, ich haette nicht alles versucht, um
hucskfjs bei seinem Problemen zu helfen? Das enttaeuscht mich
jetzt ein wenig, denn ich habe mir fuer jedes seiner Probleme (Er hat
hier im forum ja noch ein anderes Problem gepostet) einiges von
meiner (Frei-)zeit investiert, um ihm zu helfen.
Ich habe doch auch zum Head First Buch von K.S. verlinked! Das ist
ein viel besserer und einfacherer Einstieg als das Sun Tutorial, vor
allem da er geschrieben hat er haette es bereits einmal mit Buch
probiert und nichts verstanden.
Wir haben hucskfjs meiner Meinung nach den schnellsten Weg
beschrieben, ueber den er seine Probleme loesen laesst.
Das Problem ist seine "Ich will das jetzt haben aber ich will nicht
lernen wie es geht" Einstellung:
is mir alles wurscht ich will jz nur den
verdammten code wissen wie man dieses bild einblendet
Dein Link ist ihm also wurscht. Was er will ist eine Zeile
Zaubercode.
Die Frage ist nicht wie ich die beiden Collections vergleiche, dass sollte machbar sein. Das einzige was ich mich Frage ist wie die Collections aufgebaut sind.
# ( ( 3 ) # ( 5 9 ) #( 12 34 7 8)) wäre dies so sinnig?
Jörg
Weil Deine Frage so noch nicht beantwortet wurde: Ja, so in etwa
koennten die Collections aufgebaut sein: Listen, deren Kinder
entweder weitere Listen (= subknoten) oder atomare Werte (=blaetter)
enthalten koennen, bilden einen Baum und sind fuer Deine Aufgabe
geeignet:
(list 'erstesElementEbene1 'zweitesElementEbene1 (list 'erstesElementEbene2 'zweitesElementEbene2 (list 'erstesElementEbene3) ) 'viertesElementEbene1 )
Und auch wenn Du nicht danach gefragt hast: Ein Algorithmus zum
Vergleichen koennte z.B. wie folgt aussehen:
#! Lisp
(define-function compare (a b)
(conditions
;; wenn a und b beides leere listen sind, sind sie natuerlich gleich:
((and (not a) (not b)) true)
;;wenn a und b listen sind, dann sind sie gleich wenn
;;1.) die ersten beiden elemente dieser beiden listen
;;gleich sind, und 2.) wenn die beiden rest-listen
;;ebenfalls gleich sind:
((and (is-a-collection? a) (is-a-collection? b))
(and
(compare (first-element-from a) (first-element-from b))
(compare (other-elements-from a) (other-elements-from b)) ) )
;;ansonsten vergleiche einfach die beiden atomaren elemente miteinander:
((= a b))))in den 2 semestern ist allerdings nicht all zuviel rum gekommen; grundlagen von c und c++, also ich kann jetzt ziemlich gut mit einer klasse den abstand zweier punkte berechnen ;)...
Viele Einsteiger glauben, dass graphische Applikationen zu programmieren (also mit Fenstern und Menüs usw.) etwas fuer fortgeschrittene Programmierer ist. Schliesslich gibt man in Kursen und Lehrbuechern zu Beginn meistens alles auf der Kommandozeile aus. Und graphische Applikationen sehen ja auch viel komplexer aus.
Tatsaechlich bedeutet eine graphische Anwendung zu programmieren einfach nur, ein paar neue Bibliotheken zu verwenden (Was wirklich schwierig ist, ist die Programme bei steigender Komplexitaet lesbar zu halten). Deinem Ziel bist du also vermutlich naeher als du denkst (oder auch viel weiter weg).
Du kannst Dich zum Beispiel entweder mit entweder Java oder mit .NET auseinandersetzen. Beides sind Softwareplattformen, die ueber riesige Klassenbibliotheken verfuegen. Beide sind in der Wirtschaft sehr gefragt (macht sich gut im Lebenslauf) und mit beiden kannst Du auch recht einfach grafische Applikationen erstellen. Mit deinen 2 Semestern C++ hast Du einen sehr guten Start zum lernen. Ein Buch wie Head First Java oder Thinking In Java sind zum Beispiel zu empfehlen.
Auf Java wird meistens mit der Programmiersprache Java programmiert (ja, die heisst ganz genauso wie die Plattform), fuer .NET sind die Sprachen C# und Visual Basic.NET populaer. Dann gibt es noch die abstrakteren Sprachen wie Python oder Ruby, mit denen Du ebenfalls auf Java oder .NET programmieren kannst. Diese Sprachen sind maechtiger (einfacher) als Java oder C#, letztere sind aber gerade eindeutig im Mainstream.
Wenn es Dir vor allem darum geht, Statistiken zu berechnen und zu visualisieren, dann wuerde ich mir aber als erstes mal R ansehen: http://www.r-project.org/ . Das ist genau fuer solche Dinge gemacht.
Von C++ wuerde ich eher die Finger lassen: Da musst Du dich nur mit Problemen wie Speichermanagement rumschlagen, die fuer Dich vermutlich (und fuer die meisten Programme) voellig irrelevant ist.
Einige Programme werden mit einem Installer ausgeliefert: Wenn du das
Programm benutzen möchtest, mußt Du es "installieren", d.h. es
werden verschiedene Teile des Programms an verschiedene Stellen des
Systems kopiert und sogar manchmal bestehende Teile des Systems
verändert.
Eine so installierte Version des Programms ist dann nur noch schwer
auf eine DVD zu sichern, und noch schwerer später von der DVD aus
wieder herzustellen.
Was du machen kannst ist entweder:
Ein Backup des gesamten Betriebsystems zu machen.
Die Installationsroutinen (also das was Du dir z.B. aus dem Internet
heruntergeladen hast) zu sichern. Im Ernstfall mußt Du die Software
dann mit den Installern neu installieren.
Letzeres ist meistens voellig ausreichend, denn Du must ja nur die
Programme sichern, die Du nicht jederzeit wieder aus dem Internet
herunterladen kannst und die Du nicht eh bereits als DVD gekauft hast.
Deine persoenlichen Daten zu sichern ist wesentlich dringender.
a9bejo: was ich vergessen habe zum hinschreiben, meine sache ist ein wenig komplexer, also es geht um mehrere funktionen mit mehreren parametern und so beim kurz ueberfliegen des observer interfaces schauts nicht so aus als wuerde die das koennen.
Alles klar, trotzdem hier noch zwei Bemerkungen:
Mehrere funktionen mit mehreren parametern sind mit dem Observer Pattern eigentlich kein Problem. Mit der im JDK enthaltenen API kannst Du zumidnest statt einem push einen pull ansatz verwenden. D.h. anstatt das B das integer oder was auch immer direkt mit der Nachricht schickt, bekommt der Observer nur eine Message, das sich der Zustand von B veraendert hat. A holt sich dann von B alles, was es braucht:
public void set(final Observable observable) {
observable.addObserver(new Observer() {
public void update(Observable o, Object arg) {
final B b = (B) o;
neuerInt(b.getSomeInteger());
b.somethingElse();
...
});
}Zum anderen musst du ja nicht die JDK implementierung ( java.util.Observable und java.util.Observer ) verwenden. Das Observer Pattern ist das haeufigste Pattern, das im JDK verwendet wird, aber dort wird es fast immer mit eigenen Interfaces implementiert (z.B. Listener in awt/swing).
Eine eigene Implementierung besteht auch nur aus zwei Interfaces, mit der Du dann ganz leicht beliebig viele Methoden unterstuetzen kannst:
interface Observable{
void addObserver(Observer observer);
void removeObserver(Observer observer);
void notifyObservers();
}
interface Observer{
//some sample methods:
void onNewInt(int i);
void onNewString(String str);
void onNewDate(Date date);
void onAnythingElse(Observable obs);
//...
}Wie gesagt ist das event in C# ja auch nur eine (in die Sprachsyntax eingebaute) Implementierung von Observer.
delegates in C# sind nichts weiter als eine Abstraktion fuer das Command Pattern. Events wiederum sind eine Abstraktion des Observer Pattern.
Da sich sowohl Oberserver als auch Command in Java abbilden lassen, kann man deinen Code auch in Java umsetzen:
import java.util.Observable;
import java.util.Observer;
import java.util.logging.Logger;
public final class Test {
public static void main(String[] args) {
final B b = new B();
new A().set(b);
b.produceAnInteger();
}
}
final class A {
final Logger logger = Logger.getLogger(A.class.getName());
public void set(final Observable observable) {
observable.addObserver(new Observer() {
public void update(Observable o, Object arg) {
neuerInt((Integer) arg);
}
});
}
private void neuerInt(final Integer n) {
logger.info("I got this shiny new Integer from B: " + n);
}
}
final class B extends Observable {
public void produceAnInteger() {
final Integer n = 5;
setChanged();
notifyObservers(n);
}
}Im Beispiel verwende ich eine Implementierung des Observer Pattern, das mit dem JDK ausgeliefert wird. Das ist hier praktisch, allerdings ist es auch sehr leicht selber nachzubasteln (Die API aus dem JDK hat auch einige Nachteile, z.B. das Klasse B von einer abstrakten Klasse ableiten muss, oder das man immer setChanged(); vor notifyObservers aufrufen muss).
Der Link ist beim zweiten mal einfach abgebrochen: Ich hatte einfach die URL gepostet, die ich schon vor beim erstem mal gepostet habe, als ich dich auf eclipse verwiesen habe: Da hat jemand genau das selbe problem wie du und da steht auch wie du den sourcelevem umstellst.