flashpixx

HTML != XML Man kann HTML nur dann als XML parsen, sofern Du sicher gestellt hast, dass es sich um XHTML Daten handelt

Eine Klasse wird nur über den Namen (und ggf. Packagenamen) und nicht den Dateinamen geladen. Folgende beiden Codes funktionieren: class run { public static void main(String[] args) { try { Class.forName("load"); } catch (Exception e) { e.printStackTrace(); } } } und die entsprechende load-Klasse: class load { int x = 5; } Sofern die load-Klasse im Classpath liegt, wird sie auch geladen.

Eine Klasse, die via Class.fromName geladen wird, liegt normalerweise im Classpath, d.h. Du solltest Die Klassen, die Du laden willst erst einmal so versuchen zu laden.

Nimm dafür den Classloader (hier ist das nett erklärt Java Classloader ). Einfach die statische Methode forName oder loadClass (von Class) verwenden.

In PHP kann man Klassen erstellen PHP: Klassen und Objekte - Manual wobei man dort dann entsprechende Diagramme erzeugen kann.

Wieso? Per Putty kann ich auf einen Linux Host via SSH von Windows verbinden. Sofern auf dem Linux eine GUI läuft kann man sich auch via X11 oder VNC remote auf die GUI verbinden. Wenn der Linux Host in einem VMware System läuft, existiert direkt ein bowserbasierter Player, bei Virtualbox nimmt man RDP. Du hast dann eben n Testsysteme virtualisiert (natürlich entsprechende Hardware vorausgesetzt auf dem die VMs laufen). Aber wenn Du eh nur Webanwendungen testest, dann braucht man nicht viel auf dem Linux Host, lediglich Apache, mySQL und PHP (ich würde mir da ein Gentoo aufsetzen und minimal installieren. Den Portage einmal zentral auf einem Server lagern und alle System mit DistCC ausstatten, damit man schneller kompilieren kann). Das Aufrufen der Webanwendung kann ich dann von meinem lokalen Rechner aus. Natürlich muss die VM von meinem lokalen PC erreichbar sein (also richtiges Netz) und wenn externe Mitarbeiter mitarbeiten sollen, dann baut man eben ein VPN auf. Git Rep sind natürlich auch im LAN verfügbar. Wieso musst Du das auf einem Managed-Server laufen lassen? Du willst es doch eh nur testweise machen, ein SVN hast Du, d.h. Du kannst Dir lokal einen alten Rechner mit einem Linux + Apache aufsetzen und darunter dann das Git laufen lassen und gegen das SVN synchronisieren. Sorry, aber ich sehe da beim besten Willen überhaupt keine Probleme. Ich gehe davon aus, dass im System entsprechende Benutzerrollen & zentrale Authentifizierungsmechanismen existieren, so dass ich die Reps nur dort anhängen und dann für das Rep die Zugriffsrechte konfigurieren muss. Die VMs bindet man eben analog ein bei Linux würde das via PAM geschehen. Die einzige Arbeit die besteht, eben einmal zu evaluieren welche VMs mit welchen Softwareständen man braucht, ggf den Virtualisierungsserver kaufen & installieren, dann die VMs installieren und das Git Rep aufzusetzen. Bei den VMs würde ich eben ein System wie Gentoo verwenden, weil ich über den Portagetree bestimmte Pakete in der entsprechenden Version blockieren kann, so dass eben genau die Libs installiere, die in der passenden Version benötigt werden (es sollte auch mit anderen Distributionen möglich sein). Man muss dann nur eben eine Struktur sich ausdenken, wie die einzelnen Entwickler Zugriff auf die Testsysteme erhalten, d.h. falls zwei Entwickler parallel auf dem gleichen Testsystem arbeiten, sie sich nicht gegenseitig die Daten zerstören, aber hier kann man ggf VMs clonen und über eine entsprechende Nachricht beim Login auf der VM eine Warnung erzeugen (z.b. mit who kann man das in der /etc/profile oder /etc/bashrc verankern). Ich würde das Webroot Directory bzw Datadir des DB Server entsprechend irgendwo ablegen, wo jeder dann schreiben kann und ggf per Cron einmal am Tag die Daten entfernen / aufräumen, damit die VMs nicht überlaufen. Wenn Du ein Entwicklungsgitrep hast, wo nur die Entwickler Zugriff haben, dann kannst Du beim Logout bzw Login auf den VMs sogar automatisch den Stand des Entwickler updaten / einpflegen. Ggf kannst Du die kundenbezogenen Sourcen über Tags bzw Annotated Tags zuordnen. Tags wären z.B. die Release Stände, die Annotated Tags z.B. die Kundennummer / Name. Da die VM ja kundenspezifisch ist, könntest Du anhand der VM und des eingeloggten Entwicklers die passenden Daten für den Kunden über die Annotated Tags bestimmen und auschecken. Wenn der Entwickler sich ausloggt, werden die Daten eben von der VM in das Entwicklunsrep gepushed. Wenn dann ein Releasestand (kundenspezifisch) erzeugt wird, dann muss aus dem Entwicklerrep eben anhand der Tags die Daten ermittelt werden und ggf dann auf den Release Server gepushed werden (auf den Release Server sollten dann nicht alle Schreibzugriff haben). Also so würde ich das auch umsetzen, denn ich habe einmal das Rep für die Entwickler, wo jeder seine tägliche Arbeit einchecken kann (das man auch zentral an ein Backup hängen sollte). Die Testsysteme bleiben konsistent und laufen nicht voll, weil man hier immer nur die Daten liegen hat, die man für das Testen braucht. Ein zentrales Rep steht zur Verfügung, auf dem dann die Releases entstehen. Man würde eben bei einem neuen Release die Daten aus dem Entwicklersystem nehmen und z.B. als Prereleasestand kennzeichnen. Mit diesem Stand geht man dann in eine definierte Testumgebung und testet. Treten Fehler auf, werden nur diese Fehler in dem Prelease behoben. Die normale Entwicklung ist davon nicht betroffen und läuft weiter. Ist die Testphase abgeschlossen erzeugt man aus dem Prelease den Release und mergt diesen in die Entwicklung

Ich habe im Moment Entwicklungen in PHP und C++. Ich habe auf meinem lokalen System die Libs liegen, gegen die ich linke (das ganze mit Hilfe von Scons, damit es cross-plattform ist). Bei PHP habe ich einen lokale Apache, mySQL und PHP laufen. Sofern die Daten einen Stand erreicht haben, wo ich sie dann Teste, gehen sie in mein Entwicklungsrep und ich checke sie dann auf dem Testsystem aus und teste dann (wobei ich auf das Testsystem via SSH zugreife). Änderungen am Code werden somit immer auf meinem lokalen System gemacht. Naja da wäre mein Vorschlag, damit Du Dich schon mal damit auseinander setzen kannst, dass Du einfach das SVN Rep in ein Git Rep spiegelst. Soweit ich das im Kopf habe, kann man mit Git-Svn beide Reps synchron halten (schau aber da bitte noch einmal genau nach). Evtl wäre es ja sinnvoll, wenn das mit der Synchronisierung klappt, dass Du eben erst einige Entwickler von Git überzeugst und so eben Stück für Stück den Prozess migrierst.

Ich gehe mal bei den Daten, die hier verarbeitet werden sollen, von gewöhnlichen Textdaten aus. Wobei wir dann hier schon diverse Möglichkeiten haben, ASCII basiert oder Unicode basiert, wobei dort zu unterscheiden ist, ob man UTF-8 oder UTF-16 codiert. Wenn man das mit Chararrays korrekt und vollständig bearbeiten will, dann ist das ein nicht unerheblicher Aufwand. Wobei man eben genau das mit Hilfe von Strings library - C++ Reference in C++ umsetzen kann und eben nicht sämtliche Zugriffsoperationen dann händisch durchführt.

Vielleicht nur mal so als Anmerkung: Freundschaftsbeziehungen lassen sich als ungerichteten Graph darstellen (wenn Person A mit B befreundet ist, dann ist B auch mit A befreundet). Technisch beschreibt man das mit Repräsentation von Graphen im Computer Du wirst in dieser Darstellung das Problem haben, dass die Datenmenge quadratisch mit der Anzahl der Personen wächst (wobei man aber meist eine sparse Matrix erhält, da nicht jedes Element besetzt ist). Ein relationale Datenmodell ist dafür eine schlechte Wahl. Ein System was solche Beziehungen abbilden kann wäre z.B. Apache Cassandra - Wikipedia, the free encyclopedia

Git auch eine SVN Schnittstelle: git-svn(1) Warum FTP !? Das ist unverschlüsselt und ich habe keinen Zugriff auf dein Rep. Nein Du hast mein Posting nicht richtig gelesen: Jeder Entwickler hat lokal seine IDE und greift lokal auf sein Git Repository zu. In sein lokales kann er comitten, einen Revert machen usw. Erst wenn er meint, dass er die Arbeit abgeschlossen hat, pushed er sein lokales Rep in das "globale". Umgekehrt pulled er die Änderungen der anderen Entwickler in sein lokales. Er kann damit lokal eigene Zweige erzeugen und so unabhängig von den anderen Sachen testen / entwickeln. Erst wenn eben ein neuer Stand erzeugt wird, müssen alle Entwickler ihre Änderungen in das globale Rep pushen, dieses wird dann auf einem Testsystem ausgecheckt und liegt dort ebenfalls lokal. Wenn jetzt während dem Testfehler auftauchen, dann committet man diese Änderungen in das lokale Rep auf dem Testsystem, ist man mit dem Test fertig, pushed man es wieder in das globale und erzeugt so den endgültigen Release Stand. Die Verwaltung der Testsysteme muss man dann zentral machen und eben entsprechend pflegen. Wenn man eben Kunden hat, die in den Entwicklungszyklus eingebunden sind, dann können diese eben bei einem neuen Release sich eine Vorabversion aus dem Git Rep auschecken und auf ihrem Realsystem testen, wobei sie eben mit der entsprechenden Berechtigungen auch Änderungen erst in ihr lokales Rep committen und dann ggf in das Entwicklungsrep pushen. Du musst im Entwicklunsprozess bitte immer hier (auch in der Diskussion) unterscheiden: Testing und Entwicklung. Das Staging bezieht sich nur auf die Tests, aber Änderungen, die bei Tests auffallen müssen auch rückwirkend in die Entwicklung eingehen, d.h. aber Deine Entwicklungswerkzeuge müssen einen solchen Prozess unterstützen. Da Du eben noch individuelle Anpassungen pro Kunde haben kannst, musst Du eben ein Tool einsetzten, was eben solche nicht-linearen Entwicklungszyklen unterstützt. Natürlich gehört zu dem Einsatz eines solchen Systems entsprechende Akzeptanz auf allen Seiten. Das ist aber kein technisches, sondern menschliches Problem. Wenn Du Deinen Entwicklungsprozess optimieren willst, so dass eben möglichst viele Probleme ausgeschlossen / verbessert werden, dann müssen sich alle an einen Tisch setzen und darüber sprechen. SVN wird bei diesem Prozess nicht funktionieren, weil Du im schlimmsten Fall eine nicht-lineare Entwicklung hast und das kann SVN eben nicht. Und sorry, aber für Git gibt es Konsolentool und auch GUIs, je nach IDE wird Git direkt bzw mit entsprechenden Plugins unterstützt, so dass hier sicherlich nicht das Argument bezüglich schlechter Usability zählt. Außerdem wird der Linux Kernel mit Hilfe von Git entwickelt, so dass ich da fachlich sicherlich kein Argument finden kann, warum das nicht funktionieren sollte.

Okay, das ist schon etwas anderes. Aber im Grunde war mein Hinweis auf Git schon richtig. Also Du hast Deinen Source zu irgendeinem Stand (Release), nun passt machst Du kundenspezifische Anpassungen, das entspricht in der Gitterminologie einem Branching, da Du für den Kunden aus dem aktuellen Stand einen eigenen Zweig entwickelst. Im worst-case hast Du eben für jeden Kunden einen Zweig. Wenn Du nun feststellst Du willst kundenspezifische Anpassungen in den Hauptzweig mit übernehmen, dann machst Du ein merging. Um das ganze nun zu testen, musst Du eben eine VM haben, die eben das Rechnersystem des Kunden nachbildet, also im worst-case auch für jeden Kunden ein System, aber dadurch, dass Du Git benutzt, kannst Du die Sourcen immer aus dem Repository passend ziehen, d.h. Deine VMs müssen nicht den Code halten. Natürlich solltest Du Dir auch überlegen wie Du die Zweige handelst, spontan würde ich sagen, dass ich zwei Git Repository baue, auf einem wird der Hauptzweig abgelegt und auf einem anderen die kundenspezifischen Anpassungen. Du kannst das natürlich alles in ein Repository packen, aber das müsstest Du durchdenken. Der Kunde selbst kann via Git (und den entsprechenden Rechten) eben seinen Zweig aus dem zentralen Repository auschecken bzw. Änderungen, die vor Ort gemacht werden, gelangen dann automatisch in den Zweig des Kunden. Die Entwickler bestimmen halt selbst wo bzw mit was die lokal arbeiten, da Git lokal auch ein eigenes Repository pflegt. Soweit das ganze von der Codeorganisation, denn ein SVN ist bei so etwas durchaus etwas unhandlich. Wenn Du nun eben den Hauptzweig updatest, dann musst Du ja ggf Änderungen von dort in den Zweige der Kunden übertragen, bei SVN wird das schon etwas schwierig. Ich würde was die Testumgebungen angeht einmal schauen, wie differenziert Du das überhaupt brauchst, für Webentwicklungen brauchst Du pro Kunde ja keine eigene VM, es würde da ja reichen einen zentralen Webserver mit diversen Virtuellen Hosts anzulegen und einen zentralen DB Server. Da Du auf dem Testsystem für jeden Kunden einen eigenen VHost hast, brauchst Du dort nur den entsprechenden Zweig aus dem Repository abzulegen. Wenn doch einmal der Fall eintreten sollte, dass man etwas isoliert testen muss, dann zieht man sich eben lokal / zentral schnell eine VM hoch bzw. Du könntest ja diverse VMs mit unterschiedlichem Softwarestand erzeugen, so dass ich als Entwickler nur die VM anwerfen muss und dort eben den entsprechenden Zweig auschecke.

Wir müssten hier etwas die Begrifflichkeiten definieren, denn "Staging" bedeutet im Sinne der Versionskontrolle, dass kein zentrales Repository existiert und jeder Entwickler sich sein lokales Stage selbst zusammenstellt. Da mit SVN arbeitest widerspricht das irgendwie dieser Philosophie, da SVN eben rein zentral organisiertes System ist. Ich würde dann wirklich Git nehmen, denn Git unterstützt eine verteilte Architektur. Zweitens wäre in meinen Augen wichtig zu definieren, wann man innerhalb der Entwicklung einen neuen Milestone erreicht, d.h. aber für die Organisation des Codes würde dann zu diesem Zeitpunkt ein "Maintainer" den aktuellen Stand als neuen Milestone kennzeichnen und ggf auf ein zentrales Repository bringen, d.h. aber dass in diesem Repository immer der letzte gültige "Releasestand" enthalten ist. Das wäre jedenfalls mal ein Grobkonzept mit dem man arbeiten kann. Durch Git können einzelne Entwickler / -gruppen auch eigene Entwicklungszweige generieren und diese ggf. später wieder dem zentralen Zweig hinzufügen. Für das Testing der Entwicklung muss man dann eben aus dem Repository nur die entsprechenden Zweige extrahieren. Wenn man auch aktuelle Entwicklungen testen will, muss man sofern man nicht Zugriff auf alle Entwickler hat, auch noch ein Entwickler-Repository pflegen. Das Testen kann dann letztendlich im Grunde mit einem System geschehen, da man aus dem Repository eben die einzelnen Zweige extrahiert und dann direkt testet (sofern keine tiefgreifenen Systemkomponenten betroffen sind, sollte das ohne weiteres auf einem System möglich sein).

"Geht nicht" ist keine aussagekräftige Fehlermeldung

Wie man Fragen richtig stellt: eine Anleitung wie man Fragen erfolgreich in Usenet, Mailing Listen und Webforen stellt.

Dann arbeitest Du aber wie unter C und nicht OOP wie unter C++. Du solltest Dich entscheiden, ob Du C programmieren willst oder C++, aber Mischmasch ist nicht sinnvoll. In Deinen ganzen Postings ist kein vollständiger Code zu sehen

Das ist keine Begründung. Wieso soll man das mit einem Vector, der Strings enthält nicht können? Ich kann die Anzahl der Elemente des Vektors bestimmen und auch die Länge jedes einzelnen Elements. Wieso ein 2D Array? Ich kann jede Zeile lesen und anhand des Seperators auftrennen z.B. mit Usage - Boost 1.46.1 und über jeden Block iterieren. Es sollte sich auch mit STL Strukturen durchführen lassen.

Das sieht aber eher nach C Code als C++ Code.

Da Du Protokolle einsetzt, die die Integrität der Daten sicherstellen, brauch Du das nicht mehr selbst zu machen, d.h. Du brauchst eine Signatur und ggf eine PKI

Als weitere Alternative kann man das Device / Partition auch über die UUID ansprechen. Für beides finden sich Informationen in der Manpage von mount

Generell ein Tip: Halte Dich an die allgm gültige Notation, in der Klassen nicht Uppercase benannt werden. In Deiner Methode "Lehrer_zuordnen" weist Du klehrer ein neues Objekt einer (!) Lehrerklasse zu, da klehrer als Array deklariert ist, wird das nicht funktionieren. Entweder musst Du klehrer anders deklarieren und dann verwenden oder Du weist das neue Objekt einer entsprechenden Position des Arrays zu. Generell würde ich in diesem Fall davon abraten Arrays zu verwenden, da diese statisch sind. Schau Dir das Collectioninterface an (Collection (Java 2 Platform SE v1.4.2) )

mit dem entsprechenden mkfs-Tool (bei XFS mkfs.xfs -L <Label max 12 Zeichen>) das die Parameter -l bzw -L hat, kann ein Label gesetzt werden.

Benutze nicht die Partitionen sondern mounte dadurch, dass Du den Partitionen ein Label gibst.

Nein das wird hier nicht benötigt, denn der Rechner soll nicht automatisch das Optimum finden, sondern die Schritte sollen durch den Benutzer beeinflusst werden, d.h. es soll nur eine Begrenzung der vom Benutzer gegebenen Antworten statt finden. Da es sich um einen diskreten und beschränkten Datenraum handelt, kann man sehr einfach vorgehen. Denn betrachtet man das ganze im Sinne eines Lösungsbaums können alle Wege, die nicht zu einer Lösung führen direkt ignoriert werden, so dass bei einem Knoten direkt die Entscheidung für einen richtigen Weg fallen kann, d.h. das Bellman-Prinzip, dass man mehrere Teilprobleme lösen musst, ist insoweit nicht erfüllt, da man Teilprobleme, die nicht für die Lösung relevant sind, direkt ignorieren kann.

Es wird von Dir erwartet, dass Du die Teile, die Du entworfen hast, hier zeigst.

vector - C++ Reference