Community Documents

cancel
Showing results for 
Search instead for 
Did you mean: 

Quellcodeverwaltung in LabVIEW und Richtlinien für Entwicklergruppen bei anspruchsvoller Konfigurationsverwaltung

Dieser Artikel ist Teil einer Serie über die Entwicklung großer Anwendungen in LabVIEW und Verfahrensweisen bei der Softwareentwicklung. Um den Wissensaustausch zu ermöglichen, wird er der LabVIEW-Entwicklergemeinschaft zur Bearbeitung zugänglich gemacht. Bitte tragen Sie Erkenntnisse und optimale Verfahrensweisen bei. Jegliche Art von Werbung oder Angebote für Dienstleistungen werden sofort entfernt. Andere Artikel zu Themen rund um die Softwareentwicklung finden Sie hier.

Das Originaldokument in englischer Sprache sowie Kontaktdaten des Authors finden Sie hier.

Übersicht

Dieser Artikel untersucht die Entwicklung von LabVIEW-Anwendungen in Entwicklergruppen und gibt Empfehlungen zur Organisation und Verteilung von Programmcode mit Werkzeugen wie dem LabVIEW-Projekt-Explorer, Projektbibliotheken und Drittanbietern von Quellcodeverwaltungssoftware.

Inhaltsverzeichnis

  • Die Herausforderungen der Anwendungsentwicklung in der Gruppe
  • Empfehlungen für Entwicklergruppen
  • Quellcodeverwaltung in LabVIEW
  • Kompatible Quellcodeverwaltungssoftware für NI LabVIEW
  • Wie funktioniert Software zur Quellcodeverwaltung?
  • Integration von Quellcodeverwaltung in LabVIEW
  • Empfohlene Einstellungen für die Integration in LabVIEW
  • Kategorien der Quellcodeverwaltung
  • Umgebungsoptionen
  • Verschieben von Anwendungen in die Quellcodeverwaltung
  • Verwalten der Projektdatei in der Quellcodeverwaltung
  • Verwendung von Projektbibliotheken zur Verteilung von Codemodulen
  • Dateien ein- und auschecken
  • Umbenennung bestehender LabVIEW-Dateien in der Quellcodeverwaltung
  • Vermeidung von Codekollisionen
  • Konfigurierung der grafischen Verflechtung für die Verwendung mit Quellcodeverwaltung
  • VI-Revisions-Historie
  • Grafischer Vergleich
  • Zusammenfassung der Empfehlungen
  • Häufig gestellte Fragen zur Anwendungsentwicklung in Gruppen

Die Herausforderungen der Anwendungsentwicklung in der Gruppe

Kaum ein Ingenieur arbeitet alleine an einer großen, komplexen LabVIEW-Anwendung. In den meisten Fällen arbeitet ein Team von Entwicklern gemeinsam an einem Programmcode. Ohne wohlüberlegte Investitionen in Infrastruktur und Planung birgt die Entwicklung in der Gruppe jedoch ein gewisses Risiko. Zu den größten Herausforderungen von High-Level-Entwicklungen in der Gruppe gehören:

  • Rückverfolgbarkeit und Identifizierung von Änderungen am Programmcode
  • Verteilung von Codemodulen an Entwicklerteams
  • Finden und Beheben von Konflikten im Quellcode
  • Zentralisierter Zugriff auf alle Codeversionen
  • Integration von Änderungen am Master-Code

Alle Änderungen über einfache elektronische oder verbale Kommunikation zu koordinieren ist beinahe ein Ding der Unmöglichkeit. In vielen Fällen nehmen Entwickler, oft ohne es selbst zu bemerken, Ad-hoc-Änderungen an Steuerungsprozessen vor, indem sie mehrere Versionen eines Codemoduls auf einer Festplatte speichern. Dies führt jedoch zu Komplikationen, da die chronologische Entwicklung des Codes nicht mehr ersichtlich ist. Der Entwicklungszyklus wird verlängert. So muss beispielsweise in dem Fall, dass Änderungen an einem bestimmten Codemodul zu Problemen führen, wenn es in das Gesamtprojekt integriert wird, Zeit dafür aufgewendet werden, eine Vorgängerversion des Codes zu finden, die richtig funktioniert. Außerdem muss man wissen, welche Änderungen zwischen dieser und der fehlerhaften Version vorgenommen wurden.

Ohne einen definierten Prozess der Verwaltung von Änderungen gehen Fehlerbehebungen verloren oder werden falsch gewartet. Die Unterschiede zwischen Versionen sind nicht klar ersichtlich und Änderungen, die ein Entwickler vorgenommen hat, werden vom übrigen Team nicht ausreichend berücksichtigt. Dies alles führt zu fehlerhaftem Code und einer ineffizienten Entwicklung. Darüber hinaus geht oft Arbeitsaufwand verloren, wenn mehrere Entwickler dieselben Dateien bearbeiten, da durch Änderungen Daten überschrieben werden können. Eine Infrastruktur, die solche Szenarien verhindert und die Entwickler darüber informiert, dass Änderungen zusammengeführt werden müssen, ist von höchster Bedeutung.

Empfehlungen für Entwicklergruppen

Diese Empfehlungen werden in den folgenden Abschnitten genauer diskutiert.

  • Verwendung von Quellcodeverwaltung während der Entwicklung, um Dateien von allen Entwicklern zurückzuverfolgen und zu speichern
  • Integration der Quellcodeverwaltung in LabVIEW
  • Entwicklung der Anwendungsarchitektur und der Programmierschnittstelle für die Kommunikation so früh wie möglich
  • Dokumentation von Änderungen zur besseren Rückverfolgbarkeit
  • Verteilung großer Codemodule mithilfe von Projektbibliotheken

Quellcodeverwaltung in LabVIEW

Die effiziente Verwaltung großer Anwendungen erfordert Prozesse zu koordinierten Änderungen am Quellcode. Software zur Quellcodeverwaltung bietet eine Lösung für das Problem der Steuerung des gemeinsamen Codezugriffs, indem eine zusätzliche Ebene für die Kommunikation eingefügt wird. Entwickler müssen die Software informieren, wenn sie bestimmte Dateien ändern möchten und alle Änderungen beschreiben, die neu übergebender Code enthält. Die Software speichert neu übergebenen Code zum Zweck der Wiederherstellbarkeit zusammen mit älteren Versionen. So können Entwickler beobachten, welche Dateien von welchen Teammitgliedern geändert werden und frühere Versionen der Dateien einsehen.

Die wichtigsten Vorteile des Einsatzes von Quellcodeverwaltung sind:

  • Zentrale Codeablage
  • Behebung von Codekollisionen
  • Dokumentation von Verhaltensänderungen
  • Identifizierung von Zeitpunkt und Verursacher von Änderungen
  • Neueste Codeversion für jeden Entwickler
  • Sicherungskopien der verschiedenen Codeversionen

Die Kontrolle des Zugriffs auf Code vermeidet auch versehentlichen Datenverlust. Die Software für die Quellcodeverwaltung dokumentiert Änderungen an Codemodulen und ermöglicht die Verwendung von Dateien durch mehrere Anwender und über mehrere Softwareprojekte hinweg. Außerdem fördert sie die Wiederverwendung von Code, das dieser mehreren Entwicklern zur Verfügung steht.

Die Software gewährleistet, dass Änderungen am Code chronologisch zurückverfolgt werden und für alle Teammitglieder konsistent sind. Wird innerhalb eines Entwicklerteams Quellcodeverwaltung eingesetzt, fördert dies auch die Wiederverwendung von Code. Alle Aspekte des Projekts sind in einer zentralen Ablage zu finden, auf die jedes Teammitglied zugreifen kann.

Kompatible Quellcodeverwaltungssoftware für NI LabVIEW

NI LabVIEW ermöglicht die Integration von Standardsoftware für die Quellcodeverwaltung, wie etwa Microsoft Visual SourceSafe, Perforce, Rational ClearCase, PVCS Version Manager, MKS Source Integrity und kostenfreie, offene Software wie CVS. Diese Integration verleiht Anwendern Zugriff auf Funktionalität von Drittherstellern innerhalb der LabVIEW-Umgebung. Weitere Informationen über die Hersteller von Software zur Quellcodeverwaltung, die in LabVIEW integriert werden kann, steht in der Knowledge Base unter Source Control Options in LabVIEW 8 zur Verfügung.

Wie funktioniert Software zur Quellcodeverwaltung?

Die Software zur Quellcodeverwaltung pflegt eine zentralisierte Master-Kopie von Anwendungsdateien. Bearbeitet ein Entwickler eine Datei, checkt er sie dazu gewissermaßen aus der zentralen Ablage der Software aus. Sind die Änderungen komplett, checkt er die neue Version der Datei wieder ein. Sie wird dann Teil der Master-Kopie des Entwicklungsprojekts. Jedes Mal, wenn eine Datei eingecheckt wird, fordert die Software zur Quellcodeverwaltung den Anwender auf, die vorgenommenen Änderungen zu beschreiben. Es ist von großer Bedeutung, dass Entwickler Veränderungen detailliert beschreiben, die das Verhalten des Codes ändern. Dies ist zu einem späteren Zeitpunkt, wenn Revisionen zurückverfolgt werden müssen, sehr wertvoll.

Die Software zur Quellcodeverwaltung pflegt diese Informationen, so dass Entwickler die Fortschritte jeder Datei in einem Projekt deutlich nachvollziehen können. Die Revisionen jedes Codeabschnittes werden für die Dauer des Projekts in der Software zur Quellcodeverwaltung gespeichert. Unterschiede zwischen Versionen können mittels grafischem Vergleich (siehe weiter unten) dargestellt werden.

Integration von Quellcodeverwaltung in LabVIEW

Nach Installation der gewählten Software zur Quellcodeverwaltung kann LabVIEW so konfiguriert werden, dass Entwickler die Funktionalität zur Quellcodeüberwachung von der Entwicklungsumgebung aus verwenden können. Das Ziel dieser Integration besteht darin, dass Entwickler gängige Aufgaben wie etwa das Ein- und Auschecken von Dateien und das Ansehen des aktuellen Dateistatus ohne einen separaten Client und ohne die LabVIEW-Umgebung zu verlassen, durchführen können. Einige Anbieter von Quellcodeverwaltung bieten proprietäre oder erweiterte Funktionalität, für die Entwickler immer noch den Client benötigen. Jedoch sollten die meisten Aufgaben aus LabVIEW heraus ausgeführt werden können.

Die Integration kann über das Menü Werkzeuge > Quellcodeverwaltung erfolgen. Diese Funktionalität steht allerdings nur im LabVIEW Professional Development System zur Verfügung. Jede auf einem Computer installierte und von LabVIEW unterstützte Software zur Quellcodeverwaltung erscheint automatisch im Drop-down-Menü (siehe Abb. 1).

Empfohlene Einstellungen für die Integration in LabVIEW

Nach Auswahl der Software, die zur Quellcodeverwaltung mit LabVIEW eingesetzt wird, sollte man sich ein paar Einstellungen unter dem Menüpunkt Optionen bewusst machen.

Kategorien der Quellcodeverwaltung

  • Hierarchie beim Hinzufügen von Dateien ergänzen. Diese Option ist standardmäßig aktiviert und wird generell empfohlen. Beim Hinzufügen eines Top-Level-VIs zur Quellcodeverwaltung wird der Anwender automatisch dazu aufgefordert, alle SubVIs und Abhängigkeiten dieser Datei anzugeben.
  • vi.lib ausschließen. Der Inhalt dieses Verzeichnisses sollte eigentlich nie geändert werden, da vi.lib die Low-Level-VIs enthält, die mit LabVIEW installiert werden. So ist es meist unnötig, diese Dateien zur Quellcodeverwaltung hinzuzufügen, doch sie können dabei helfen zu zeigen, dass keine Änderungen vorgenommen wurden.

Umgebungsoptionen

  • Schreibgeschützte VIs als gesperrt behandeln. Wurde eine Datei vom Entwickler nicht ausgecheckt, erlaubt die Quellcodeverwaltung lediglich den Lesezugriff. Wird diese Option gewählt, können Entwickler ein VI nicht bearbeiten. Die Auswahl dieser Option wird generell empfohlen, doch Anwender müssen eine Datei auf jeden Fall auschecken, bevor sie Änderungen speichern können.
  • Automatische Änderungen nicht speichern. Änderungen an SubVIs können zu Low-Level-Änderungen am Binärcode des aufrufenden VIs führen. Normalerweise macht LabVIEW diese Änderungen automatisch und speichert die Datei. Dieser Vorgang kann allerdings deaktiviert werden, um keine Revision eines VIs zu speichern, welches das Verhalten nicht beeinflusst

Verschieben von Anwendungen in die Quellcodeverwaltung

Die Organisation und Verwaltung von Anwendungen wird in einem anderen Artikel diskutiert („Umfangreiche Anwendungen in NI LabVIEW mit dem Projekt-Explorer verwalten), der erläutert, wie man die Dateihierarchie am besten strukturiert und wie man Anwendungen in den LabVIEW-Projekt-Explorer migriert. Sobald die Quellcodeverwaltung wie oben beschrieben konfiguriert wurde und sich die Anwendungsdateien im Projekt-Explorer befinden, können sie dem Quellcode-Depot über das Menü Werkzeuge > Quellcodeoptionen oder über einen Klick mit der rechten Maustaste auf die entsprechende Datei im Projekt-Explorer und Auswahl von Zur Quellcodeverwaltung hinzufügen ganz einfach hinzugefügt werden.

Die Quellcodeverwaltung kann auch zum Management all jener Ressourcen im Projekt-Explorer verwendet werden, die eine zugehörige Datei auf der Festplatte haben. Dazu gehören VIs, Dokumentation, Bilder und die Projektdatei. Anforderungsdokumente werden oft in der Quellcodeverwaltung gespeichert, so dass Entwickler Änderungen in der Dokumentation nachvollziehen und den Verlauf von Revisionen einsehen können. Besonders wichtig ist das bei zertifizierten Entwicklungsmethoden, wobei Entwickler oft beweisen müssen, dass sich die Änderungen an den Anforderungen im Programmcode widerspiegeln. Werkzeuge wie der Requirements Gateway von National Instruments sind nützlich für die Erstellung von Berichten, die die Erfüllung von Anforderungen bestätigen und Informationen zur Rückverfolgbarkeit liefern.

Weitere Informationen über das Requirements Management bietet das Dokument „Abbildung von Anforderungsdokumenten auf LabVIEW-Code mithilfe des NI Requirements Gateway“.

Wird die Quellcodeverwaltung in einem bestehenden LabVIEW-Projekt konfiguriert, wird der Anwender nach Ergänzung jedes vorher im Projekt gespeicherten VIs dazu aufgefordert, die neue Datei der Quellcodeverwaltung hinzuzufügen. Diese Aufforderung erscheint nur bei bestehenden Dateien. Neue VIs haben keine Entsprechung auf der Festplatte, bis sie gespeichert werden. Deshalb können sie auch nicht der Quellcodeverwaltung hinzugefügt werden. Das Ergänzen eines Projekts mit Dateien während der Entwicklung führt neue Links ein und hat Änderungen an der Projektdatei zur Folge. Dieser Vorgang muss sorgfältig verwaltet werden und wird im nächsten Abschnitt genauer behandelt.

Empfohlene Vorgehensweisen

  • Vor der Festlegung von Abhängigkeiten und Links sollte die Architektur einer Anwendung entwickelt werden.
  • Das Top-Level-VI wird der Quellcodeverwaltung im Idealfall zuerst hinzugefügt, so dass alle statisch verlinkten Dateien automatisch ergänzt werden.
  • Die Projektdatei sollte sich in der Quellcodeverwaltung befinden.

Verwalten der Projektdatei in der Quellcodeverwaltung

Es wird empfohlen, die Projektdatei bzw. die Datei *.lvproj einer Anwendung in der Ablage für die Quellcodeverwaltung zu speichern. Diese Datei enthält Links zu physikalischen Ressourcen im Projekt-Explorer, die relative Pfade zu den Speicherorten von Dateien, den Einstellungen eines bestimmten Projekts sowie virtuelle Objekte wie etwa Build-Spezifikationen enthalten. Alle Entwickler müssen stets die aktuelle Version der Datei *.lvproj nutzen, um sicherzustellen, dass sie die neuesten Abhängigkeiten und Ressourcen verwenden.

Das Hinzufügen oder Umbenennen von Dateien in einem Projekt ändert die Inhalte der Datei *.lvproj, so dass es notwendig ist, diese Datei auszuchecken und eine neue Revision von ihr zu speichern. Da diese Änderungen alle Entwickler betreffen, welche *.lvproj verwenden, ist davon abzuraten, während der Entwicklungsphase Änderungen vorzunehmen. Ist dies trotzdem notwendig, sollten sie nur von einem Anwender auf einmal bearbeitet werden. Alle anderen Entwickler sollten die neueste Revision der Datei erhalten, sobald die Änderungen abgeschlossen sind. Falls dies allerdings nicht möglich ist, gibt es auch andere Alternativen.

Im Idealfall wird die Architektur der Anwendung vor der Entwicklung festgelegt und es gibt Platzhalter für künftigen Programmcode und Funktionalität. Trotzdem kann es vorkommen, dass Änderungen nötig sind, die zu einer Überarbeitung der Architektur und daher auch der Inhalte der Datei *.lvproj führen. Diese Änderungen beeinflussen unter Umständen Verbindungen in der gesamten Anwendung und sollten deshalb nicht auf die leichte Schulter genommen werden. Die empfohlene Vorgehensweise besteht hier darin, die Änderungen offline und außerhalb des Entwicklungsprozesses vorzunehmen. Danach sollten alle Dateien ins Depot eingecheckt und gesperrt werden, so dass sie nicht wieder ausgecheckt werden können. Des Weiteren ist es wichtig, sicherzustellen, dass der neue Code von Anforderungsdokumenten abgedeckt wird und dass diese dokumentieren, warum die Dateien hinzugefügt wurden.

Verwendung von Projektbibliotheken zur Verteilung von Codemodulen

Bei großen, komplexen LabVIEW-Anwendungen ist es beinahe unmöglich, im Voraus zu wissen, welche Codemodule für die Entwicklung von Low-Level-Funktionalität nötig sein werden. Die Verwendung von Projektbibliotheken umgeht dieses Problem, da Informationen über die Inhalte einer Projektbibliothek nicht in der Datei *.lvproj gespeichert sind. Details über die Organisation großer Codemodule und deren Weitergabe an mehrere Entwickler mithilfe von Projektbibliotheken liefert das Dokument „Austausch von Programmcode mithilfe der LabVIEW-Projektbibliothek“.

Werden jedoch Änderungen an Dateien innerhalb der Projektbibliothek vorgenommen, die von Code außerhalb der Bibliothek aufgerufen werden, ändern sich auch Links von aufrufenden Objekten, die dann aktualisiert werden müssen. Die Verwendung von APIs kann dieses Problem abmildern, wenn eine feste Gruppe von Dateien erstellt wird, die von Code außerhalb der Projektbibliothek aufgerufen wird. Projektbibliotheken ermöglichen bei verschiedenen Dateien Zugriffseinstellungen für den öffentlichen oder den privaten Gebrauch. Private Dateien können nur von innerhalb der Projektbibliothek aufgerufen werden und deshalb keine Links außerhalb modifizieren. Die öffentlichen Dateien liefern die Schnittstelle, über die andere Codemodule Programmcode innerhalb der Projektbibliothek ausführen.

Empfohlene Vorgehensweisen

  • Speichern der Projektdatei in der Quellcodeverwaltung
  • Frühzeitige Entwicklung der Anwendungsarchitektur unter Berücksichtigung künftiger Funktionalität
  • Weitergabe der aktuellen Projektdatei an alle Entwickler
  • Einrichtung von APIs für die Kommunikation zwischen Codemodulen und Projektbibliotheken
  • Vermeidung der Bearbeitung der Projektdatei während der Entwicklung
  • Verwendung von Projektbibliotheken zur Erstellung von Codemodulen, die modifiziert werden können, ohne die Projektdatei zu beeinflussen

Dateien ein- und auschecken

Einer der wichtigsten Vorteile der Verwendung von Quellcodeverwaltung in einem Entwicklungsprozess ist die Möglichkeit, Änderungen an Codemodulen zu regulieren und zu überwachen. Muss ein bestimmter Teil des Codes überarbeitet werden, checkt man das entsprechende Codemodul zunächst aus dem zentralen Depot aus. Dies geschieht über das Menü Werkzeuge > Quellcodeverwaltung oder durch Rechtsklick auf die Datei(en) im Projekt-Explorer. Der Projekt-Explorer bietet eine intuitive und bedienfreundliche Methode für die Organisation und Wartung aller Elemente eines Softwaredesignzyklus.

Neben den ausgecheckten Dateien erscheint im Projekt-Explorer ein rotes Häkchen. Hat ein anderer Programmierer bereits eine Datei ausgecheckt, erscheint daneben ein blaues Häkchen. Erlaubt die Quellcodeverwaltung das gleichzeitige Auschecken einer Datei, ist sowohl ein blaues als auch ein rotes Häkchen neben der Datei zu sehen.

!file+status.png!

Zur manuellen Aktualisierung des im Projekt-Explorer angezeigten Status einer Datei in der Quellcodeverwaltung wählt man Werkzeuge > Quellcodeoptionen > Status aktualisieren. Dies sollte geschehen, bevor große Gruppen von Dateien ausgecheckt werden. So sieht man, ob eine oder mehrere der Dateien bereits von anderen Entwicklern benutzt werden.

Umbenennung bestehender LabVIEW-Dateien in der Quellcodeverwaltung

Die Quellcodeverwaltung speichert den Verlauf der Revisionen einer Datei basierend auf dem Namen des VIs. Beim Ändern eines VI-Namens muss man sich unbedingt an einen speziellen Prozess halten, damit der Verlauf der Revisionen nachvollziehbar bleibt. Auch sollte sichergestellt werden, dass alle Links von Abhängigkeiten zu den Dateien innerhalb der LabVIEW-Anwendung erhalten bleiben.  Dazu dient folgende Anleitung für statisch verbundene Dateien, die momentan in der Quellcodeverwaltung gespeichert sind.

  • Projekt mit der Anwendung in LabVIEW öffnen. – Hinweis: Das gesamte Projekt muss geöffnet sein, nicht nur die Datei, damit LabVIEW die Umbenennung erkennt.
  • Alle Dateien auf einen einzigen Rechner auschecken.
  • Umbenennung aus der Quellcodeverwaltung vornehmen.
  • Zu LabVIEW zurückkehren und das LabVIEW-Projekt mit der Taste F5 aktualisieren. An der umbenannten Datei ist eine Fehlermeldung zu sehen, die darauf hinweist, dass die Datei umbenannt oder von d
  • Festplatte entfernt wurde.
  • Mit der rechten Maustaste auf die Datei klicken und „Ersetzen durch“ auswählen.
  • Neue Version der Datei suchen und auswählen.
  • Alle Links sollten so erhalten bleiben und der Verlauf der Revisionen wird immer noch mit dem VI assoziiert.

Vermeidung von Codekollisionen

Die meisten Anbieter von Quellcodeverwaltung haben Administratorrechte und können Dateien sperren, wenn sie aus dem Codedepot ausgecheckt werden. So kann nur ein Anwender auf einmal den Code bearbeiten und es treten keine Konflikte auf, weil mehrere Entwickler ein Stück Programmcode gleichzeitig geändert haben. Das Sperren ist die einfachste und effektivste Methode, um Codekollisionen zu vermeiden. Sollte es einmal notwendig sein, dass mehrere Entwickler gängige Dateien zur selben Zeit bearbeiten, kann man alle ihre Änderungen auch kombinieren. Die Quellcodeverwaltung speichert beide Kopien der Datei, so dass Entwickler LabVIEW-VIs zusammenführen können. Dies kann mithilfe der im nächsten Abschnitt behandelten LabVIEW-Funktion der grafischen Verflechtung manuell oder automatisch erfolgen.

Konfigurierung der grafischen Verflechtung für die Verwendung mit Quellcodeverwaltung

Bei der Entwicklung großer Anwendungen müssen oftmals Modifikationen eines Entwicklers mit einer Masterkopie des Codes vereinbart werden. In vielen Fällen werden Codedepots in der Quellcodeverwaltung genutzt, die tatsächlich einen „Zweig“ des Masterdepots an Dateien darstellen. Sind die Änderungen vollständig, müssen bei der Integration von Modifikationen auch Updates am Master-Quellcode berücksichtigt werden. Dieser Prozess kann manuell ausgeführt, oder aber über die Funktion der grafischen Verflechtung erheblich beschleunigt und vereinfacht werden. Die grafische Verflechtung kann aus der Entwicklungsumgebung heraus unter dem Menü „Werkzeuge“ ausgeführt oder so konfiguriert werden, dass sie abläuft, wenn die Quellcodeverwaltung einen Konflikt erkennt, der eine Zusammenführung erfordert.

Software zur Quellcodeverwaltung kann auch textbasierte Dateien zusammenführen. Probiert man jedoch, LabVIEW-VIs mit textbasierten Programmen zusammenführen, werden diese versuchen, die in der Datei gespeicherten Binärdaten zu kombinieren. Software zur Quellcodeverwaltung kann so konfiguriert werden, dass sie bei einem Befehl zum Zusammenführen von Dateien mit bestimmten Dateinamenerweiterungen externe Anwendungen aufruft. Bei LabVIEW-VIs kann die Funktion zur grafischen Verflechtung extern aufgerufen werden. Dann werden ihr die entsprechenden für die Zusammenführung notwendigen Parameter mitgeteilt.

Das Aufrufen der grafischen Verflechtung von einer externen Anwendung erfordert die Möglichkeit, Parameter an die Kommandozeile weiterzugeben. Unter Windows ist die auszuführende Datei unter folgendem Pfad zu finden: C:\Program Files\National Instruments\Shared\LabVIEW Merge\LVMerge.exe.

Es gibt vier erforderliche und einen optionalen Parameter, die dem Aufruf an die ausführbare Datei folgen müssen:

  1. (Optional): Spezifiziert den Pfad zu der LabVIEW-Version, die für die Zusammenführung verwendet werden soll. Wird dieses Argument nicht geliefert, nutzt das Dialogfeld VIs zusammenführen standardmäßig folgende LabVIEW-Version:
  2. Pfad zu einer Kopie des VIs an dem Ort, von wo es ausgecheckt wurde (Base VI)
  3. Pfad zu einer Kopie der aktuellen Revision des VIs in der Quellcodeverwaltung (Theirs VI)
  4. Pfad zum VI, das vom Anwender bearbeitet wurde (Yours VI)
  5. Pfad zum Ort, an dem das zusammengeführte VI gespeichert werden soll

Wie diese Interaktion konfiguriert wird, hängt von der verwendeten Software zur Quellcodeverwaltung ab. Zu Demonstrationszwecken kann diese Funktionalität aber auch, wie unten gezeigt, von der Befehlszeile aufgerufen werden:

In Perforce kann diese Funktionalität aus dem Menü 'Einstellungen >> Optionen' konfiguriert werden. Aus den Kategorien wird „Zusammenführen“ ausgewählt und damit die standardmäßige Einstellung für jede Datei mit der Dateinamenerweiterung *.vi außer Kraft gesetzt.

Die Verwendung der grafischen Verflechtung innerhalb der Entwicklungsumgebung wird im Artikel „Funktion zur grafischen Verknüpfung einzelner LabVIEW-VIs“ näher erläutert.

VI-Revisions-Historie

Während aus LabVIEW auf die Software zur Quellcodeverwaltung zugegriffen wird, kann eine Beschreibung der an einer Datei vorgenommenen Änderungen ergänzt werden, wenn sie in die Quellcodeverwaltung eingecheckt wird. Diese Information wird in der Revisions-Historie für die betreffende Datei in der Software zur Quellcodeverwaltung gespeichert. So können alle Änderungen an einem Projekt zurückverfolgt und dem jeweiligen Anwender zugeordnet werden. Fehler können einfach zurückverfolgt werden, ohne dass man den tatsächlichen Code betrachten muss, um herauszufinden, was geändert wurde. Eine Revisions-Historie kann nicht nur für LabVIEW-VIs gepflegt werden, sondern für jede Datei, die dem LabVIEW-Projekt hinzugefügt wurde. Ein Entwickler kann beispielsweise die Software zur Quellcodeverwaltung nutzen, um Änderungen an Spezifikationen und anderen Dokumenten zurückzuverfolgen. Die Revision-Historie für alle Dateien kann unter Werkzeuge > Quellcodeverwaltung > Historie zeigen abgerufen werden (siehe unten).

Das Dialogfeld zur Revisions-Historie, das dann erscheint, wird von der konfigurierten Software zur Quellcodeverwaltung zur Verfügung gestellt. Abbildung 6 zeigt etwa die Revisions-Historie der Projektdatei Initialize.vi, die in einem Depot von Visual Source Safe gespeichert ist.

Die Dialogfenster unterscheiden sich von Anbieter zu Anbieter. In Visual Source Safe gibt es eine Vielfalt zusätzlicher Optionen, die an der rechten Seite der Revisions-Historie aufgelistet sind. Wählt man Details, während eine bestimmte Revision markiert ist, werden alle vom Entwickler bei der Überprüfung eingegebenen Kommentare sowie Informationen zu Datum und Uhrzeit angezeigt (siehe Abbildung 7).

Eine weitere Funktion in Visual Source Safe und anderer Software zur Quellcodeverwaltung ist die Möglichkeit, ältere Versionen eines Codemoduls aus dem Depot aufzurufen. Abbildung 8 zeigt diese Funktion, wie sie erscheint, wenn Visual Source Safe für die Quellcodeverwaltung konfiguriert wird. Falls die aktuelle Version eines Codemoduls nicht mehr richtig funktioniert, kann man mittels dieser Funktion eine ältere, funktionstüchtige Version des Codes aufrufen.

Grafischer Vergleich

Bei vielen Methoden der Softwareentwicklung müssen Entwickler Änderungen verfolgen und dokumentieren, wenn Code überarbeitet wird. So können Modifikationen leicht identifiziert und Tests auf geändertem Programmcode durchgeführt oder wiederholt werden.

Der grafische Vergleich steht in LabVIEW zur Verfügung, um den Prozess des Vergleichs verschiedener Versionen einer Datei zu erleichtern. So kann man VIs direkt nebeneinander vergleichen, wobei Änderungen hervorgehoben werden. Die Funktion zum grafischen Vergleich kann im Menü Werkzeuge > Quellcodeverwaltung oder nach Auswahl von „Unterschiede anzeigen“ nach einem Rechtsklick im Projekt-Explorer aufgerufen werden.


Das momentan gespeicherte VI wird mit der letzten Version desselben VIs verglichen, die in das Depot der Quellcodeverwaltung eingecheckt wurde. Alle Unterschiede, von Positionsänderung eines Frontpanel-Bedienelements bis hin zu umfangreichen Ergänzungen von Funktionalität, werden dem Anwender angezeigt. Beispielsweise kann die Version des Main.vi aus dem Speicher mit dem Main.vi verglichen werden, das zuletzt ins Depot der Quellcodeverwaltung eingecheckt wurde. Die Funktion zum grafischen Vergleich zeigt, dass mehrere Elemente aus einem Cluster entfernt wurde, indem die Unterschiede in beiden Blockdiagrammen durch einen Kreis markiert werden.

Hinweis: Die in LabVIEW verfügbare Funktion zum grafischen Vergleich ist mit Perforce und Microsoft Visual Source Safe umfassend getestet worden. Nur diese beiden Softwareprodukte zur Quellcodeverwaltung unterstützen offiziell die Funktion in LabVIEW. Soll eine Software zum Einsatz kommen, welche die Integration des Vergleichs nicht unterstützt, kann dieser auch manuell vorgenommen werden. Dazu wählt man aus dem Werkzeugmenü „VIs vergleichen“. Alternativ lassen sich auch ganze Dateihierarchien vergleichen, Wenn man „VI-Hierarchien vergleichen“ auswählt.

Zusammenfassung der Empfehlungen

Bei großen Projekten, bei denen viele Dateien involviert sind und Teams von Entwicklern gemeinsam an einem Softwareprodukt arbeiten, ist die Quellcodeverwaltung unverzichtbar. Durch den Einsatz von Prozessen zur Quellcodeverwaltung im Softwareentwicklungszyklus lässt sich die gesamte Produktivität erhöhen und die Implementierung großer Projekte beschleunigen. LabVIEW arbeitet innerhalb strukturierter Softwareentwicklungsprozesse, in welche die favorisierte Software zur Quellcodeverwaltung integriert werden muss.

  • Die Integration muss aktiviert werden, um generische Befehle der Quellcodeverwaltung von innerhalb der Entwicklungsumgebung steuern zu können.
  • „Hierarchie hinzufügen“ muss ausgewählt werden, um sicherzustellen, dass alle SubVIs mit aufrufenden Objekten in die Quellcodeverwaltung platziert werden.
  • Die Inhalte von vi.lib sollten ausgeschlossen werden, denn an diesem Speicherort sollte keine Entwicklung stattfinden.
  • „Schreibgeschützte VIs als gesperrt behandeln“ sollte gewählt werden, um zu verhindern, dass Anwender Dateien ändern, die sie nicht ausgecheckt haben.
  • Auch die Projektdatei sollte in die Quellcodeverwaltung integriert werden.
  • Auch muss festgelegt werden, wie und wann sich verschiedene Teile einer Anwendung aufeinander beziehen.
  • Sinnvoll ist es, die Architektur der Anwendung und Platzhalter-VIs vor der Entwicklung zu planen.
  • Während der Entwicklung sollten keine Änderungen an der Architektur vorgenommen werden.
  • Kleinere Änderungen sollten nur von einem Entwickler auf einmal bearbeitet werden.
  • Größere Änderungen sollten nicht vorgenommen werden, während andere Entwickler Dateien ausgecheckt haben.
  • Alle Vorgehensweisen sind strikt zu reglementieren.
  • Alle Anwender sollten sich absprechen, nachdem Änderungen vorgenommen wurden. Wird das neue Projekt aufgerufen, ist zu sehen, welche Dateien fehlen.
  • Die Notwendigkeit für Modifikationen an Links innerhalb einer Anwendung sollte mittels Projektbibliotheken und APIs minimiert werden.

Häufig gestellte Fragen zur Anwendungsentwicklung in Gruppen

1. Warum wurde die Quellcodeverwaltung aus LabVIEW entfernt?

National Instruments bietet die Integration mit Dritthersteller-Software zur Quellcodeverwaltung, um Entwicklern zu ermöglichen, beim Konfigurationsmanagement und der Überwachung von Änderungen von Software nach Industriestandard zu profitieren.

2. Umfasst LabVIEW integrierte Tools zur Quellcodeverwaltung, für die keine Software von Drittherstellern nötig ist?

Im Unterschied zu früheren LabVIEW-Versionen, umfasst LabVIEW 8.x keine Werkzeuge zur Quellcodeverwaltung. Allerdings wurden zahlreiche Optionen von Drittherstellern mit LabVIEW 8.x getestet, darunter auch kostenlose Open-Source-Software wie etwa CVS (nur für PushOK-Windows-Clients).

3. In welche Version von LabVIEW kann Drittherstellersoftware für die Quellcodeverwaltung integriert werden?

Das LabVIEW Professional Development System (PDS) ermöglicht die Integration von Drittherstellersoftware für die Quellcodeverwaltung.

4. Gibt es eine LabVIEW-Funktion zur Behebung von Konflikten zwischen verschiedenen Versionen desselben VIs?

Ja. Außerdem gibt es eine Funktion für den grafischen Vergleich.

5. Welche Optionen gibt es für die Quellcodeverwaltung bei Linux oder Mac OS?

Wird LabVIEW auf Linux oder Mac ausgeführt, muss die Software Perforce für die Quellcodeverwaltung genutzt werden. Jedoch kann man LabVIEW mit jeder Software zur Quellcodeverwaltung einsetzen, wenn man die entsprechende Funktionalität einfach aus der Software selbst aufruft.

Contributors