Teil­neh­mer

web.sta – web basier­te Appli­ka­ti­on, Ziel-Web­brow­ser ist Inter­net Explo­rer der Ver­si­on 9 und 11

Text­Sys­tem – eine eigen­stän­di­ge Desk­top-Anwen­dung, basie­rend auf Java/Swing

Inter­me­dia­teLay­er – eine Cli­ent-Ser­ver Anwen­dung, die web.sta und Text­Sys­tem mit­ein­an­der verbindet.

web.sta kann Text­Sys­tem über den Inter­me­dia­teLay­er star­ten. Inter­me­dia­teLay­er erstellt zu die­sem Zweck einen HTTP-Ser­ver und web.sta sen­det ein­fa­che GET- oder POST-Abfra­gen an den local­host. Inter­me­dia­teLay­er ver­ar­bei­tet die Ein­gangs­pa­ra­me­ter und star­tet das Text­Sys­tem. Da kei­ne Rück­mel­dung erfor­der­lich ist, ist das Inter­ak­ti­ons­sche­ma ein­fach und robust genug.

Citrix

In einer Citrix-Umge­bung ist es nicht mög­lich, meh­re­re Lis­tening-Sockets für die­sel­be IP-Adres­se und den­sel­ben Port zu erstel­len. Man muss ent­we­der den Port oder die IP-Adres­se ändern. Citrix bie­tet jedoch einen spe­zi­el­len Mecha­nis­mus an, um die­se Ein­schrän­kung zu umge­hen, ohne den Algo­rith­mus des Pro­gramms zu ändern. Die­ser Mecha­nis­mus wird als „Vir­tu­al IP Loo­p­back“ bezeich­net. Hier muss der Admi­nis­tra­tor ein­fach die erfor­der­li­chen Anwen­dun­gen im Citrix-Kon­fi­gu­ra­ti­ons­fens­ter kon­fi­gu­rie­ren. Die Anwen­dung, die „local­host“ für Socket-Ver­bin­dun­gen ver­wen­det, erhält nicht 127.0.0.1, son­dern eine IP-Adres­se in der Form 127.0.0.<SID + 1>, wobei SID die Sit­zungs-ID des Win­dows-Benut­zers ist.

Die Pro­ble­ma­tik

Unter IE9 (und auch mit ande­ren Brow­sern) unter Win­dows Ser­ver 2008 R2 funk­tio­nier­te dies alles ein­wand­frei. Dann jedoch woll­te der Kun­de etwas Neu­es und Win­dows Ser­ver 2012 R2 erschien mit IE11. Das gan­ze Sys­tem hör­te auf zu funk­tio­nie­ren. Unab­hän­gig von den Citrix Ein­stel­lun­gen ver­sucht IE11 bei Abfra­gen auf „local­host“ immer eine Ver­bin­dung zu 127.0.0.1 her­zu­stel­len, die­se natür­lich schei­tert, weil auf der Adres­se kei­ner Hörer (Lis­tener) gibt. Nach ein wenig Recher­che kamen wir zu dem Schluss, dass dies ein Bug in IE11 sein muss.

Rou­tingSer­vice

Wenn die Vir­tua­li­sie­rung des „local­host“ in Citrix-Box für IE11 nicht funk­tio­niert, schrei­ben wir sie selbst!
Des­halb ent­schlos­sen wir uns, selbst einen Win­dows-Dienst zu erstel­len, der ein ein­fa­cher Web­ser­ver ist und zu 127.0.0.1 eine Ver­bin­dung auf­baut und damit alle Abfra­gen auf der Grund­la­ge der Sit­zungs­num­mer des Benut­zers an den gewünsch­ten Inter­me­dia­teLay­er umlei­ten. Wir haben kei­ne ein­fa­che Lösung gefun­den, um die SID zu ermit­teln, aber in den Umge­bungs­va­ria­blen haben wir sofort SES­SI­ONNA­ME gefun­den. Im Inter­net Explo­rer bekom­men wir über ActiveX die­se Umge­bungs­va­ria­ble und über­ge­ben sie als Para­me­ter in der HTTP-Abfra­ge wei­ter. Im Rou­tingSer­vice erhal­ten wir durch den Sit­zungs­na­men unter wtsapi32.lib die Sit­zungs­num­mer. Dann lei­ten wir die HTTP-Abfra­ge um und sen­den die Ant­wort an den IE zurück.

Etwas ist schief gelaufen

Wir haben mit dem Tes­ten und der Inte­gra­ti­on unse­res Ser­vice begon­nen. Aber nicht alles lief so rei­bungs­los, wie wir es uns gewünscht hat­ten.
Wie sich her­aus­stell­te, kann der Name der Sit­zung geän­dert wer­den, obwohl wir nicht ver­stan­den haben, unter wel­chen Bedin­gun­gen dies geschieht. Es kam jedoch häu­fig vor, dass der Sit­zungs­na­me geän­dert wur­de aber IE11 nur den Anfangs­wert der Umge­bungs­va­ria­blen kennt und die­sen Wert dau­er­haft an den Rou­tingSer­vice weitergibt.

Was ist in der Registry?

Es war not­wen­dig, einen ande­ren Weg zu fin­den, um den Sit­zungs­na­men zu ermit­teln. Wir haben nach Infor­ma­tio­nen zu Sit­zun­gen in der Regis­try gesucht und wur­den fün­dig: Unter HKEY_CURRENT_USER \ Vola­ti­le Envi­ron­ment ist es mög­lich eine Lis­te aller Sit­zun­gen des aktu­el­len Benut­zers abzurufen.

Wenn es nur um eine Anmel­dung geht, ist alles in Ord­nung, wir kön­nen sie lesen und ver­wen­den. Wenn es für einen Benut­zer jedoch vie­le Sit­zun­gen gibt, müs­sen wir irgend­wie fest­stel­len, in wel­cher Sit­zung wir uns befin­den. Die bes­te Mög­lich­keit die uns ein­fiel war, den Pfad zum Ord­ner mit den tem­po­rä­ren Datei­en abzugleichen.

Bei­spiel:

Im IE erhal­ten wir den aktu­el­len Pfad zu TEMP mit­hil­fe von ActiveX Scripting.FileSystemObject. Auf die­se Wei­se konn­ten wir den Namen unse­rer Sit­zung ermit­teln. Aber das ist nicht alles. Der Wert der Schlüs­sel in der Vola­ti­le Envi­ron­ment ist in der Tat die SID. Somit kön­nen wir sofort die erfor­der­li­che IP-Adres­se in Java­Script abru­fen und eine Anfra­ge an die­se senden.

Sol­len wir es vereinfachen?

Schließ­lich kön­nen wir die SID abru­fen und direkt eine Ver­bin­dung her­stel­len, ohne den Rou­tingSer­vice zu ver­wen­den. Aber der Lösungs­weg sieht immer noch nicht schön aus. Die Inter­net­su­che hat gezeigt, dass das Pro­blem besteht, aber wie es beho­ben wer­den kann wird nir­gend­wo beschrie­ben. Und auch Micro­soft bie­tet dazu bis­her kei­ne Lösung.

Wir hof­fen, dass jemand mit die­sem spe­zi­fi­schen Pro­blem von unse­rer Erfah­rung pro­fi­tie­ren kann.

In der Soft­ware Qua­li­ty Assuran­ce wer­den bei der dyna­mi­schen Qua­li­täts­si­che­rung (Soft­ware­tes­ten) ver­schie­de­ne Metho­den ange­wandt, um die Qua­li­tät von Pro­duk­ten und Pro­zes­sen abzu­si­chern. Anhand einer Doku­men­ta­ti­on wer­den die Bestre­bun­gen Ihrer Qua­li­tät test­fä­hig gemacht. Wei­ter­le­sen

Die Imple­men­tie­rung einer neu­en Soft­ware­lö­sung erfor­dert nicht nur die detail­lier­te Aus­wahl und Anschaf­fung von Pro­gram­men. Die Her­aus­for­de­rung stellt eben­so sehr die stra­te­gi­sche Ein­füh­rung der ein­zel­nen Pro­gramm­kom­po­nen­ten, sowie die Sicher­stel­lung der Kom­pa­ti­bi­li­tät zur Erschaf­fung einer inein­an­der­grei­fen­den IT-Infra­struk­tur dar. Das prä­zi­se Zusam­men­spiel tech­ni­scher und orga­ni­sa­to­ri­scher Abhän­gig­kei­ten und ein sinn­vol­ler Hand­lungs­ab­lauf müs­sen gewähr­leis­tet wer­den. Zudem müs­sen die durch die Ände­run­gen betrof­fe­nen Pro­zess­be­tei­lig­ten in die Imple­men­tie­rung ein­ge­bun­den wer­den, um die Akzep­tanz der neu­en Pro­zes­se im Unter­neh­men zu garan­tie­ren. Nur durch Übung in einem Test­um­feld kann die Sicher­heit für die spä­te­re Pra­xis geschaf­fen wer­den. Ledig­lich anwen­der­freund­li­che Pro­zes­se füh­ren in der Pra­xis zum gewünsch­ten Erfolg.

Soft­ware Deve­lo­p­ment Lifecycle

Hier­zu wird der Pro­zess des soge­nann­ten Soft­ware Deve­lo­p­ment Lifecy­cle ange­wen­det. Er ist Teil des Qua­li­täts­ma­nage­ments eines jeden IT-Pro­jekts. Nach Defi­ni­ti­on der zu erar­bei­ten­den Zie­le, fin­den Aus­wahl und Ein­füh­rung der hier­für not­wen­di­gen Pro­zess­än­de­run­gen sowie IT-Kom­po­nen­ten statt. Dar­auf­hin erfolgt eine Test­pha­se, die das imple­men­tier­te Sys­tem auf Anwen­der­freund­lich­keit, Effek­ti­vi­tät und Effi­zi­enz prüft. Durch erprob­te Test­stra­te­gien und Kon­zep­te wer­den Erkennt­nis­se über mög­li­che Feh­ler in der Imple­men­tie­rung auf­ge­zeigt. Ein­zel­fall­sze­na­ri­en wer­den in einer Test­um­ge­bung simu­liert. Zudem kön­nen Ände­rungs­wün­sche zur bes­se­ren Bedie­nung ein­ge­bracht wer­den. Eine Ana­ly­se der Test­ergeb­nis­se führt gege­be­nen­falls zu einer oder meh­re­ren Repe­ti­ti­ons­pha­sen, inklu­si­ve not­wen­di­ger Feh­ler­be­he­bun­gen und Anpas­sun­gen, bis die ver­ein­bar­ten Pro­jekt­zie­le erreicht sind. Zur Mes­sung der Ziel­er­rei­chungs­quo­te kön­nen vor­de­fi­nier­te Kenn­zah­len zum Ein­satz kom­men, die indi­vi­du­ell, je nach Unter­neh­men, fest­ge­legt werden.

Durch das Soft­ware Tes­ting im Deve­lo­p­ment Pro­zess kann kein feh­ler­frei­er Betrieb des neu­en Pro­zes­ses garan­tiert wer­den, da wäh­rend der Tests ledig­lich Ein­zel­fäl­le geprüft wer­den. Aller­dings wer­den erfah­rungs­ge­mäß auf­kom­men­de Feh­ler nach Ein­füh­rung der Sys­te­me im Life­be­trieb erheb­lich reduziert.

Nicht nur für die fach­li­che Model­lie­rung von neu­en IT-Pro­zes­sen soll­te ein oder soll­ten sogar meh­re­re pro­fes­sio­nel­le Bera­ter hin­zu­ge­zo­gen wer­den. Durch stan­dar­di­sier­te und erprob­te Erfah­run­gen in der Opti­mie­rung und Auto­ma­ti­sie­rung von IT-Pro­zes­sen kön­nen exter­ne Dienst­leis­ter eben­so wert­vol­le Unter­stüt­zung wäh­rend der ein­zel­nen Ent­wick­lungs­zy­klen der Imple­men­tie­rung der Pro­zes­se bie­ten. Gera­de beim Tes­ting ist eine detail­lier­te Doku­men­ta­ti­on und Beglei­tung durch Pro­gram­mie­rer sinn­voll und not­wen­dig, damit die rich­ti­gen Schluss­fol­ge­run­gen aus den Feh­lern gezo­gen wer­den kön­nen, um die­se wie­der­um effi­zi­ent lösen zu können.

Ein­heit­li­che und ver­ständ­lich geschrie­be­ne Anwen­der­hand­bü­cher zur Bedie­nung neu­er Sys­te­me, sowie Schu­lun­gen wer­den außer­dem in der Regel durch den Dienst­leis­ter zur Ver­fü­gung gestellt und müs­sen somit nicht vom Unter­neh­men selbst kon­zi­piert werden.

SEHEN SIE UNSER SER­VICE ANGEBOT

In Zei­ten der ste­ti­gen Digi­ta­li­sie­rung ste­hen Unter­neh­men ver­stärkt vor der Her­aus­for­de­rung, die eige­ne IT-Infra­struk­tur nicht nur auf­recht zu erhal­ten, son­dern außer­dem bestehen­de Sys­te­me zu moder­ni­sie­ren und ihre Poten­zia­le durch die Umset­zung von tech­ni­schen Inno­va­tio­nen zuguns­ten ihres Wett­be­werbs­vor­teils zu nut­zen. Dabei benö­ti­gen sie auf­grund feh­len­der Eigen­res­sour­cen pro­fes­sio­nel­le Unter­stüt­zung. Doch wel­cher IT-Dienst­leis­ter passt zum jewei­li­gen Unter­neh­men? Wel­ches Leis­tungs­port­fo­lio deckt die eige­nen Erwar­tun­gen best­mög­lich ab?

Die Aus­wahl an IT-Dienst­leis­tern in Deutsch­land ist groß. Grund­sätz­lich unter­schei­det man den Markt in drei Beratergruppen.

  • Die ers­te Grup­pe stel­len die soge­nann­ten IT-Ser­vice-Dienst­leis­ter dar. Sie kon­zen­trie­ren sich auf den Betrieb von Rechen­zen­tren sowie auf War­tung und Sup­port der Anwen­dungs­um­ge­bung. Ihr Fokus liegt auf der früh­zei­ti­gen Loka­li­sie­rung von Sys­tem­stö­run­gen, Erar­bei­tung dies­be­züg­li­cher Lösun­gen sowie der War­nung, Vor­be­rei­tung und Beglei­tung des Kun­den zur not­wen­di­gen Anpas­sung der Software.
  • Die zwei­te Art der IT-Dienst­leis­ter legt ihren Schwer­punkt auf die betriebs­spe­zi­fi­sche Sys­tem­ent­wick­lung und –inte­gra­ti­on. Sie haben sich auf die Ent­wick­lung von Indi­vi­du­al­soft­ware sowie deren Betrieb spezialisiert.
  • Die drit­te Grup­pe ver­fügt über ein umfas­sen­des, zukunfts­ori­en­tier­tes Leis­tungs­spek­trum. Die­ses beinhal­tet eine Kom­bi­na­ti­on aus Manage­ment- und IT-Bera­tung mit der Ori­en­tie­rung an kun­den- und pro­jekt­spe­zi­fi­schen Anfor­de­run­gen. Dazu gehö­ren zum Bei­spiel Kon­zep­tio­nie­rung, Soft­ware­ent­wick­lung, Rea­li­sie­rung inno­va­ti­ver IT-Geschäfts­mo­del­le unter Ein­be­zug von Trans­for­ma­ti­ons­ma­nage­ment, Busi­ness Pro­zess Out­sour­cing und Busi­ness Pro­zess Management.

Aktu­ell domi­nie­ren die IT-Ser­vice-Dienst­leis­ter den deut­schen Markt des IT-Con­sul­tings. Durch die stei­gen­de Wei­ter­ent­wick­lung hin­sicht­lich moder­ner Tech­no­lo­gien wächst der IT-Bera­ter-Markt einer­seits an sich ste­tig. Ande­rer­seits ent­wi­ckeln sich die Kun­den­an­for­de­run­gen auf Basis neu­er Geschäfts­mo­del­le immer mehr in Rich­tung digi­ta­ler Trans­for­ma­ti­on. Die Nach­fra­ge nach IT-Bera­tern, die ihren Schwer­punkt auf den rei­nen Sup­port fixer IT-Struk­tu­ren in Betrie­ben gelegt haben, redu­ziert sich aktu­ell. Zuneh­mend wer­den Dienst­leis­tun­gen nach­ge­fragt, die die Geschäfts­pro­zes­se an die neu­en Bedin­gun­gen der Wirt­schaft anpas­sen. Die Unter­neh­men benö­ti­gen Unter­stüt­zung bei Pro­jek­ten wie etwa bei Expan­si­ons­vor­ha­ben, Auf­bau oder Erwei­te­run­gen der Social Media Prä­senz, der Ein­bin­dung von Cloud­lö­sun­gen oder Mul­ti-Chan­nel-Platt­for­men, mit dem Ziel, den Bedin­gun­gen der all­ge­mei­nen Moder­ni­sie­rung zu genügen.

Bei der Aus­wahl der hier­für adäqua­ten, maß­ge­schnei­der­ten Soft­ware unter­stüt­zen zukunfts­ori­en­tier­te IT-Bera­ter. In enger Zusam­men­ar­beit mit dem Unter­neh­men wer­den Pro­jekt­zie­le und Vor­ge­hens­wei­sen für den Ver­än­de­rungs­pro­zess defi­niert. Struk­tu­rier­te und erprob­te Ana­ly­se­schrit­te ermög­li­chen indi­vi­du­ell auf das Unter­neh­men ange­pass­te Projektstrategien.

SEHEN SIE UNSER SER­VICE ANGEBOT

Die exter­nen Anfor­de­run­gen an Unter­neh­men hin­sicht­lich Ser­vice­qua­li­tät, Fle­xi­bi­li­tät sowie Nach­hal­tig­keit stei­gen ste­tig an. Hin­zu kommt der erhöh­te Kos­ten­druck des frei­en Mark­tes. Unter­neh­men sind mehr und mehr gezwun­gen, ihre Pro­zes­se zu opti­mie­ren und zu auto­ma­ti­sie­ren, um wett­be­werbs­fä­hig zu blei­ben. Hier­zu ist eine genaue Auf­nah­me und Ana­ly­se der Work­flow-Land­schaft des Betriebs not­wen­dig. Wei­ter­le­sen

Ver­sio­nie­rung ist inner­halb eines Doku­men­ten­ma­nage­ment­sys­tems (DMS) kein Fremd­wort. Nor­ma­ler­wei­se bedeu­tet es, dass His­to­rie der Ände­run­gen von Doku­men­ten gespei­chert wird. In unse­rem Arti­kel wird beschrie­ben, was zu tun ist, wenn die Doku­men­te aus den Vor­la­gen erstellt wer­den und die Vor­la­gen selbst fort­ent­wi­ckelt wer­den kön­nen, ohne dass die Abhän­gig­kei­ten vom Doku­ment zur Vor­la­ge auf­ge­löst wor­den sind.

Bei grö­ße­ren Unter­neh­men wer­den für die Erstel­lung von Doku­men­ten diver­se kom­ple­xe Vor­la­gen umge­setzt. Z.B. auf XML-Basis, wie bei Gerich­ten und Staats­an­walt­schaf­ten, oder als dot-Datei von MS Word. Die Vor­la­gen kön­nen von­ein­an­der abhän­gen, modu­la­ri­siert wer­den, Includs (Collec­tions) haben und vie­les mehr. Die Doku­men­te wer­den mit dyna­mi­schen Daten gefüllt und kön­nen eine inter­ne Spra­che haben, z.B. Skript­ele­men­te oder Makros. Eine Vor­la­ge wird gela­den, ggf. inter­pre­tiert, oder es wer­den die Skrip­te gestar­tet, die eine gewis­se Dyna­mik ins Doku­ment brin­gen. Wenn in der Skript­spra­che die Bedin­gungs­ele­men­te ver­wen­det wer­den, kann es sein, dass eini­ge Vor­la­gen erst spä­ter gele­sen wer­den kön­nen, z.B. bei der nächs­ten Ses­si­on oder der nächs­ten Inter­pre­tie­rung des Doku­men­tes. Dadurch kom­men neue dyna­mi­sche Daten aus Vor­la­gen ins Dokument.

Die­sen Ablauf kann man gra­fisch wie folgt darstellen:

 

Jede XML-Vor­la­ge (oder jeder XML-Bau­stein) kann noch beding­te Ele­men­te haben und auf wei­te­re XML-Vor­la­gen ver­wei­sen. Das Pro­blem dabei: Wenn man ver­sucht, die Vor­la­gen zu erwei­tern, könn­ten alte gespei­cher­te Doku­men­te nicht mehr ablauf­fä­hig sein. Es kön­nen ver­schie­de­ne Pro­ble­me von “Varia­ble nicht gefun­den” bis “das Modul exis­tiert nicht mehr” auf­tre­ten. Um die aus die­sen Vor­la­gen erstell­ten Doku­men­te immer inter­pre­tier­bar zu hal­ten und die Abhän­gig­keit von der Vor­la­ge auf­zu­lö­sen, gibt es zur­zeit zwei Alternativen:

1. Die Vor­la­gen sol­len so ent­wi­ckeln wer­den, dass kei­ne Abhän­gig­kei­ten zwi­schen den gela­de­nen Vor­la­gen im Doku­ment und erwei­ter­ten oder neu ent­wi­ckel­ten Vor­la­gen, auch in abseh­ba­rer Zeit, ent­ste­hen können.

2. Ein Ver­sio­nie­rungs­sys­tem für die Vor­la­gen ein­füh­ren — Die Alter­na­ti­ve zu Num­mer 1 ist ein­fach, könn­te aber bei grö­ße­ren Pro­jek­ten nicht zu rea­li­sie­ren sein, weil fast bei jeder Erwei­te­rung der Vor­la­gen alle ande­ren immer von jeman­dem dar­auf hin über­prüft wer­den müs­sen, ob kei­ne Abhän­gig­kei­ten entstehen.

Ver­sio­nie­rungs­sys­tem

Die Idee ist nun, jede Vor­la­ge zu ver­sio­nie­ren. Alle XML-Vor­la­gen müs­sen dazu über ein Ver­si­ons­ver­wal­tungs­ys­tem (z.B. SVN, VSS) ver­sio­niert wer­den. Die Num­mer der Revi­si­on soll­te in der Vor­la­ge sicht­bar sein, z.B. in Form von Metadaten.

<Meta name="vss" value="{version}27{/version}" />

Die Infor­ma­ti­on wird spä­ter beim Laden von alten Doku­men­ten ver­wen­det. Das DMS soll­te nach dem Öff­nen eines alten XML-Doku­men­tes immer eine Zuord­nung je nach Erstel­lungs­da­tum von allen XML-Vor­la­gen zum Doku­ment fin­den kön­nen. Als Sche­ma könn­te man alles in einer Tabel­le darstellen:

Num­mer oder sym­bo­li­scher Name des Relea­ses von XML-Vorlagen

Ablauf der Textverarbeitung

release1 Aktuelle_XML_Vorlage_vom_2008-02–01_XX-XX-XX.zip
Die Doku­men­te wer­den im Zeit­raum von 01.02.2008 bis 07.02.2008 erstellt und gespei­chert. Alle Doku­men­te, wenn nichts ande­res von der Ver­wal­tung vor­ge­ge­ben, sol­len nur die XML-Bau­stei­ne aus der Aus­lie­fe­rung „Aktuelle_XML_Vorlage_vom_2008-02–01_XX-XX-XX.zip“ verwenden.
release2 Aktuelle_XML_Vorlage_vom_2008-02–07_XX-XX-XX.zip
Die Doku­men­te wer­den im Zeit­raum von 07.02.2008 bis 14.02.2008 erstellt und gespei­chert. Alle Doku­men­te, wenn nichts ande­res von der Ver­wal­tung vor­ge­ge­ben, sol­len nur die XML- Bau­stei­ne aus der Aus­lie­fe­rung „Aktuelle_XML_Vorlage_vom_2008-02–07_XX-XX-XX.zip“ verwenden.
release… Aktuelle_XML_Vorlage_vom_.…._XX-XX-XX.zip
…..
releaseNN Aktuelle_XML_Vorlage_vom_2008-10–15_XX-XX-XX.zip
Die Doku­men­te wer­den im Zeit­raum von 15.10.2008 bis TT.MM.JJJJ erstellt und gespei­chert. Alle Doku­men­te, wenn nichts ande­res von der Ver­wal­tung vor­ge­ge­ben, sol­len nur die XML- Bau­stei­ne aus der Aus­lie­fe­rung „Aktuelle_XML_Vorlage_vom_2008-10–15_XX-XX-XX.zip“ verwenden.

 

Die Num­mer oder eine tex­tu­el­le Bezeich­nung der Aus­lie­fe­rung (kurz „release“ oder „schnitt“) soll als Meta­da­ten­satz zum Doku­ment gespei­chert wer­den. Spä­ter, beim Laden des Doku­men­tes, gibt die­se Bezeich­nung vor, wel­che Ver­si­on der noch nicht gela­de­nen XML-Vor­la­gen in die­ses Doku­ment geholt bzw. bei Bedarf aktua­li­siert wer­den sollte.

Allen Bezeich­nun­gen des Relea­ses wer­den alle ent­hal­te­nen XML-Vor­la­gen mit eige­nen Ver­sio­nen zuge­ord­net. Falls ein Release nur eine Del­ta der XML-Vor­la­gen ent­hielt, die­se wird auch mit glei­chem Prin­zip mar­kiert. Wenn bei der Inter­pre­tie­rung des Doku­men­tes kein XML-Bau­stein in der Bezeich­nung des Relea­ses gefun­den wird, geht DMS auto­ma­tisch auf eine Ver­si­on der Bezeich­nung runter.

Wofür benö­tigt man ein Doku­men­ten­ver­wal­tungs­sys­tem (DMS)?

Das DMS dient der revi­si­ons­si­che­ren und vor allem auch platz­spa­ren­den Abla­ge von Faxen, E‑Mails sowie der digi­ta­li­sier­ten Ein­gangs­post und auch Doku­men­ten, wie zum Bei­spiel Bele­gen, Rech­nun­gen, Ver­si­che­rungs­un­ter­la­gen und Ver­trä­gen. Das DMS sorgt eben­falls dafür, dass man die­se Unter­la­gen zu einem spä­te­ren Zeit­punkt schnell und effi­zi­ent wie­der auf­fin­den kann. Natür­lich könn­te man auch ohne ein Doku­men­ten­ver­wal­tungs­sys­tem aus­kom­men, möch­te man aber die Geschäfts­pro­zes­se ver­ein­fa­chen, digi­ta­li­sie­ren und beschleu­ni­gen, ist der Schritt hin zum Doku­men­ten­ver­wal­tungs­sys­tem tat­säch­lich der rich­ti­ge. Das Wich­tigs­te ist, dass alle Doku­men­te revi­si­ons- und rechts­si­cher auf­be­wahrt sind und auch schnell wie­der­ge­fun­den wer­den können.

Wel­che Fol­gen hat es, wenn man die­ses Sys­tem nicht nutzt?

Wenn man sich für ein Doku­ment­ma­nage­ment­sys­tem ent­schei­det, dann soll­te die­ses auch genutzt wer­den. Die Doku­men­te müs­sen ins Sys­tem ein­ge­bracht wer­den, damit sie im Doku­men­ten­sys­tem ver­wal­tet wer­den kön­nen. Wenn man die­ses Doku­ment­ma­nage­ment­sys­tem ein­führt, soll­te es von allen Mit­ar­bei­tern genutzt wer­den. Es zeigt sich aber in der Regel, dass nicht jeder Mit­ar­bei­ter eine Lizenz erhält, was nicht an den Lizenz­prei­sen liegt, son­dern an den Fol­ge­kos­ten. Es ist unum­gäng­lich, dass jeder Mit­ar­bei­ter auf die­ses Sys­tem geschult wird, damit es auch opti­mal ange­wen­det wird. Dabei kön­nen mit­un­ter hohe Auf­wen­dun­gen ent­ste­hen. Wird aber ein Doku­ment­ma­nage­ment­sys­tem ein­ge­führt, aber nicht genutzt, bzw. nicht in der Form, wie es eigent­lich vor­ge­se­hen ist (also mit Doku­men­ten befüllt), ist das Vor­ha­ben schnell zum Schei­tern ver­ur­teilt. Die wich­ti­gen Daten sind damit nicht im Sys­tem abge­legt. Tritt aber der Ide­al­fall ein und es wird genutzt, dann kön­nen die Daten­ser­ver ersetzt wer­den. Nur wenn das der Fall ist, ist auch sicher gestellt, dass sich ein DMS umset­zen lässt.

Fort­set­zung folgt.

In die­sem Bei­trag möch­ten wir eini­ge Vor­tei­le der Java­FX-Biblio­thek erläu­tern, die beson­ders im Bezug auf das User­in­ter­face eine Rol­le spielt.
Als einer der wich­ti­gen Vor­tei­le der Java­FX Biblio­thek gilt die Mög­lich­keit der Nut­zung von Styles (CSS), die uns aus dem WWW bekannt sind.
Dadurch ver­liert sich die Abhän­gig­keit zu der Biblio­thek Look & Feel. Man kann jedoch selbst das Aus­se­hen der Appli­ka­ti­on bestim­men, was auch ziem­lich fle­xi­bel und schön mög­lich ist. Die Gestal­tung kann dyna­misch erfol­gen, eine Ani­ma­ti­on beinhal­ten oder auch 3D Grafik.
Durch die Benut­zung der Style-Kon­zep­ti­on ist es nun mög­lich, die Appli­ka­tio­nen mit so genann­ten “Skins” zu erstel­len, durch die das Aus­se­hen der Appli­ka­ti­on kom­plett von der Busi­ness­lo­gik los­ge­löst wird und mehr Indi­vi­du­al­tät erhält. Sol­che indi­vi­du­el­len Skins kön­nen sogar sepa­rat von einem Desi­gner erstellt werden.

Erstel­len wir ein ein­fa­ches Bei­spiel eines Dia­log­fens­ters mit einem Button:

public class JavaFXDialog1 extends Application {
    @Override
    public void start(Stage stage) {
        final VBox vbox = new VBox();
        final Button button = new Button("test");
        vbox.getChildren().addAll(button);
        final Scene scene = new Scene(vbox, 150, 100);
        stage.setScene(scene);
        stage.show();
    }
  
    public static void main(String[] args) {
        launch(args);
    }

avafx and css styles 1

Styles kann man unter­schied­lich anwenden:
1) Unmit­tel­bar im Code, um z.B. die Schrift­far­be in dem But­ton zu ändern:

button.setStyle("-fx-text-fill: red");

avafx and css styles 2

2) Mit Hil­fe einer CSS-Datei, auf die die Klas­se Sce­ne aus­ge­rich­tet wer­den soll:
Dafür wird eine Datei mit der Erwei­te­rung .css erstellt und unter dem Pro­jekt­ver­zeich­nis abge­legt, z.B. /css/styles.css.
Inhalt der Datei:

.button {
    -fx-text-fill: blue;
}

Dabei ist es sehr wich­tig, die Ent­wick­lungs­um­ge­bung so ein­zu­rich­ten, dass sie die­se CSS-Datei­en beim Bil­den der Appli­ka­ti­on auch mitkopiert.
Unter Intel­liJ IDEA wird es bei­spiels­wei­se fol­gen­der­ma­ßen gemacht:

avafx and css styles 3

Nun ist alles fer­tig, um die Style-Datei einzubinden:

scene.getStylesheets().add((getClass().getResource("/css/styles.css")).toExternalForm());

Wir star­ten das Pro­jekt und bekom­men fol­gen­des Dialogfenster:
avafx and css styles 4

Instruk­ti­on .but­ton in der CSS-Datei sagt aus, dass nun alle Knöp­fe eine blaue Schrift­far­be haben werden:

final Button button1 = new Button("button1");
final Button button2 = new Button("button2");
vbox.getChildren().addAll(button1, button2);

avafx and css styles 5

Und was, wenn das nicht das ist, was wir brau­chen? Was, wenn wir einen kon­kre­ten Knopf defi­nie­ren wollen?
3) Abhil­fe schafft die user­be­zo­ge­ne Defi­ni­ti­on des Knopf-Styles:
In styles.css schrei­ben wir:

.button1 {
    -fx-text-fill: green;
}

Und im Code:

button1.getStyleClass().add("button1");

Das Dia­log­fens­ter sieht so aus:
avafx and css styles 6

Nun haben alle Knöp­fe, die mit der Style-Klas­se ver­bun­den sind, grü­ne Schrift­far­be, wobei die Metho­de add() uns dabei Hin­wei­se gibt, dass wir meh­re­re von sol­chen Styles hin­zu­fü­gen kön­nen, wodurch ver­schie­de­ne Ele­ment­ei­gen­schaf­ten erwei­tert, vor­de­fi­niert oder über­la­den werden.
4) User-Style kann man auch durch den so genann­ten ID definieren:

In der styles.css schrei­ben wir:

#button2 {
    -fx-text-fill: yellow;
}

Und im Code:

button2.setId("button2");

Als Ergeb­nis bekom­men wir fol­gen­des Dialogfenster:

avafx and css styles 7

D.h. alle Ele­men­te mit der glei­chen ID sehen gleich aus.

Was kann man sonst noch Inter­es­san­tes mit den Styles machen?

Styles kön­nen auch die so genann­ten Ver­hal­tens­trig­ger bear­bei­ten, die aus der XAML Welt kommen.
Wenn wir bei dem Bei­spiel mit dem Knopf blei­ben, gehö­ren zu die­sen Trig­gern sol­che Ereig­nis­se der GUI wie Fokus, Selek­ti­on, Mou­se­down, Mou­seo­ver usw. also alles, was man nicht im Dia­log­fens­ter haben möch­te. Es beinhal­tet nur den Bui­siness­lo­gin bei den kun­den­sei­ti­gen Ände­rungs­wün­schen und es wird nur die CSS-Datei geän­dert und nicht die Logik.
So kann man z.B. mit der fol­gen­den CSS-Defi­ni­ti­on die Far­be des Knop­fes ändern, wenn der User mit der Maus dar­über fährt.

.button:hover {
    -fx-background-color: orange;
}

So sieht das Dia­log­fens­ter bei Mou­seo­ver aus:

avafx and css styles 8

Wie bereits oben erwähnt, führt das zum glei­chen Ver­hal­ten von allen But­ton-Klas­sen. Mit die­sem Code:

.button1:hover {
    -fx-background-color: orange;
}

wer­den die Trig­ger nur für die Ele­men­te ange­wen­det, die auf die Klas­se «button1» verweisen.

Die­se Vor­ge­hens­wei­se kann man bei vie­len Trig­ger anwen­den, bei Knöp­fen gibt es z.B. auch noch fou­sed, selec­ted oder presset.

Lei­der kann das nicht direkt im Code genutzt werden:

button.setStyle(":hover -fx-text-fill: red");

Viel­leicht wird die­se Mög­lich­keit in der Zukunft durch Java­FX Deve­lo­per realisiert.

Wozu brau­chen wir das alles? Im Inter­net kann man noch eine Rei­he an Bei­spie­len fin­den, die deut­li­cher sind als die­ses. Das Ziel des Bei­trags war nicht, die­se zu kopie­ren. Uns geht es dar­um, dass die Kon­zep­ti­on von Syles und Trig­ger  auch für den eige­nen Bedarf erwei­tert wer­den kann, das ist für uns von Interesse.

Als Bei­spiel kön­nen wir fol­gen­de Aus­gangs­si­tua­ti­on betrachten:
wir wol­len mit Java­FX eine visu­el­le Kom­po­nen­te umset­zen, die für die Aus­wahl der Grö­ße einer im Text ein­ge­füg­ten Tabel­le die­nen soll. Das Aus­se­hen der Kom­po­nen­te, das Farb­sche­ma, die Grö­ße usw., sol­len dabei kein Bestand­teil der Busi­ness­lo­gik der Kom­po­nen­te sein, son­dern über eine exter­ne CSS-Datei kon­fi­gu­rier­bar sein.

Das soll­te unge­fähr so aussehen:

avafx and css styles 9

Der User geht mit dem Maus­zei­ger über die Tabel­le und sieht sei­ne aus­ge­wähl­ten Ele­men­te, in dem Fall eine Tabel­le mit 7 x 8 Zel­len. Beim Klick auf die Kom­po­nen­te soll­te die Aus­wahl an das Pro­gramm über­mit­telt wer­den, um eine ent­spre­chen­de Tabel­le einzufügen.
Sicher­lich kann man auf die Aus­wahl über den Code reagie­ren, aber was wenn der eine Kun­de eine bestimm­te Far­be bevor­zugt, der ande­re aber ganz ande­re Far­ben bevor­zugt? Mög­lich ist auch, dass das Farb­sche­ma durch ein «Skin» oder sonst wie vor­de­fi­niert wird — was dann?

Hier wird nur eine Kom­po­nen­te für die Zel­len­se­lek­ti­on benö­tigt, um deren Aus­se­hen es an die­ser Stel­le aber nicht gehen soll.

Hier kön­nen wir auf das vor­an­ge­gan­ge­ne Bei­spiel mit dem Trig­ger «hover» für den But­ton anknüp­fen. Der wirkt aller­dings für jede Zel­le, wenn man mit dem Maus­zei­ger über sie fährt. Die Zel­len, die der Maus­zei­ger ver­las­sen hat, ent­spre­chen dem Trig­ger nicht mehr und fal­len somit aus der Aus­wahl. Wie kön­nen wir den gesam­ten Bereich aus­ge­wählt behalten?

Für die Lösung die­ser Auf­ga­be wird ein eige­ner Trig­ger erstellt, der auf eine bestimm­te Eigen­schaft des Objek­tes reagiert, z.B. «bin im Dia­pa­son der Selek­ti­on» oder inRan­ge, die wir fol­gen­der­ma­ßen in der CSS-Datei defi­nie­ren können:

.MyCell:inRange {
    -fx-border-width: 0.5;
    -fx-border-color: #ffffff;
    -fx-background-color: lightskyblue
}

An der Stel­le muss man aber sagen, dass dies ist kei­ne ein­fa­che Auf­ga­be ist. Zudem ist die Lösung für die Java­FX Ver­sio­nen 1.7 und 1.8 gänz­lich unter­schied­lich. Für die Lösung in der Ver­si­on 1.7. sind wir auf die Nut­zung einer Men­ge der depre­ca­ted-Metho­den angewiesen.

Für den Anfang schau­en wir uns die Kom­po­nen­te an:

public class JavaFXDialog2  extends Application {
    @Override
    public void start(Stage stage) {
        final VBox vbox = new VBox();
        final GridPaneEx table = new GridPaneEx();
        table.init(10, 10);
        final Label label = new Label();
        label.setMaxWidth(Double.MAX_VALUE);
        label.setAlignment(Pos.CENTER);
        label.setTextAlignment(TextAlignment.CENTER);
        label.setStyle("-fx-padding: 3 0 5 0");
        label.textProperty().bind(table.text);
        vbox.getChildren().addAll(label, table);
        final Scene scene = new Scene(vbox, 350, 300);
        scene.getStylesheets().add((getClass().getResource("/css/styles.css")).toExternalForm());
        scene.setFill(null);
        stage.setScene(scene);
        stage.show();
    }
 
 
    public static void main(String[] args) {
        launch(args);
    }
 
 
    private void fireCreateTable(final int cols, final int rows){
        System.out.println("cols = " + cols + ", rows = " + rows);
    }
 
 
    protected class GridPaneEx extends GridPane {
  
        public final StringProperty text = new SimpleStringProperty("cancel");
        private int cols;
        private int rows;
  
        public GridPaneEx(){
            this.setOnMouseExited(new EventHandler() {
                @Override
                public void handle(MouseEvent mouseEvent) {
                    text.setValue("cancel");
                    deselectAll();
                }
            });
        }
  
        public void init(final int cols, final int rows){
            getChildren().clear();
            this.cols = cols;
            this.rows = rows;
            for (int col = 0; col < cols; col++){
                for (int row = 0; row < rows; row++){
                    final Button rect = new Button();
                    rect.setMinSize(30, 10);
                    add(rect, col, row);
                    final int selectedCol = col;
                    final int selectedRow = row;
                    rect.setOnMouseMoved(new EventHandler() {
                        @Override
                        public void handle(MouseEvent mouseEvent) {
                            selectRange(selectedCol, selectedRow);
                            text.setValue((selectedCol + 1) + " x " + (selectedRow + 1));
                        }
                    });
                    rect.setOnAction(new EventHandler() {
                        @Override
                        public void handle(ActionEvent actionEvent) {
                            fireCreateTable(selectedCol + 1, selectedRow + 1);
                            deselectAll();
                        }
                    });
                }
            }
            deselectAll();
        }
  
        private Node getNodeFromGridPane(int col, int row) {
            for (Node node : getChildren()) {
                if (GridPane.getColumnIndex(node) == col && GridPane.getRowIndex(node) == row) {
                    return node;
                }
            }
            return null;
        }
  
        private void selectCell(int col, int row, final boolean select){
            final Node node = getNodeFromGridPane(col, row);
            if (select){
                node.setStyle("-fx-border-width: 0.5; -fx-border-color: #ffffff; -fx-background-color: lightskyblue");
            } else {
                node.setStyle("-fx-border-width: 0.5; -fx-border-color: #000000; -fx-background-color: #ffffff");
            }
        }
  
        public void deselectAll(){
            for (int col = 0; col < cols; col++){
                for (int row = 0; row < rows; row++){
                    selectCell(col, row, false);
                }
            }
        }
        private void selectRange(int selectedCol, int selectedRow){
            deselectAll();
            for (int col = 0; col <= selectedCol; col++){
                for (int row = 0; row <= selectedRow; row++){
                    selectCell(col, row, true);
                }
            }
        }
    }
}

Beson­ders inter­es­sant ist die Metho­de select­Cell, in der die Zel­len­fär­bung unmit­tel­bar im Code rea­li­siert wird:

Für nor­ma­le Zellen:

node.setStyle("-fx-border-width: 0.5; -fx-border-color: #000000; -fx-background-color: #ffffff");

Für Zel­len im aus­ge­wähl­ten Bereich:

node.setStyle("-fx-border-width: 0.5; -fx-border-color: #ffffff; -fx-background-color: lightskyblue");

Weil es in der Auf­ga­ben­be­schrei­bung steht, dass kla­re Far­ben­zu­wei­sung unmög­lich ist, ver­su­chen wir die mit Hil­fe eines eige­nen Styles in styles.css zu definieren:

#MyCellNormal {
    -fx-border-width: 0.5;
    -fx-border-color: #000000;
    -fx-background-color: #ffffff;
}
 
 
#MyCellInRange {
    -fx-border-width: 0.5;
    -fx-border-color: #ffffff;
    -fx-background-color: lightskyblue
}

Und in der Metho­de selectCell:

private void selectCell(int col, int row, final boolean select){
            final Node node = getNodeFromGridPane(col, row);
            if (select){
                                node.setId("MyCellNormal");
            } else {
                                node.setId("MyCellInRange");
            }
        }

Schon bes­ser, nicht war? D.h. wenn der Kun­de mit der Farb­wahl unzu­frie­den sein soll­te, kann man sie direkt in der Datei styles.css ändern. Die Logik der Kom­po­nen­te bleibt dabei unverändert.

Aller­dings gibt es eine noch ele­gan­te­re Lösung der Auf­ga­be: Plat­zie­ren wir in styles.css noch zusätz­lich 2 Sytles:

.MyCell {
    -fx-border-width: 0.5;
    -fx-border-color: #000000;
    -fx-background-color: #ffffff;
}
 
 
.MyCell:inRange {
    -fx-border-width: 0.5;
    -fx-border-color: #ffffff;
    -fx-background-color: lightskyblue
}

Das bedeu­tet, dass die Zel­len sich auf den Style «MyCell» ori­en­tie­ren und wenn der Trig­ger «inRan­ge» greift, ana­log zu «hover» oder «pres­set», ändert sich die Far­be entsprechend.
Aber wie brin­gen wir der Zel­le bei, den Trig­ger zu starten?
Da wir in unse­rem Bei­spiel für die Zel­len, But­ton-Ele­men­te nut­zen, ist es erfor­der­lich ihr Ver­hal­ten in der so genann­ten Pseu­do-Klas­se neu zu defi­nie­ren. In Java­FX 1.7 wird das so gemacht:

protected static class RangeButton extends Button {
        public RangeButton(){
            getStyleClass().add("MyCell");
        }
 
 
        private BooleanProperty inRange = new BooleanPropertyBase() {
 
 
            @Override
            protected void invalidated() {
                impl_pseudoClassStateChanged("inRange");
            }
 
 
            @Override
            public Object getBean() {
                return RangeButton.this;
            }
 
 
            @Override
            public String getName() {
                return "inRange";
            }
        };
 
 
        public boolean isInRange() {
            return inRange.get();
        }
 
 
        public void setInRange(boolean value) {
            inRange.set(value);
        }
 
 
        private static final long IN_RANGE_PSEUDOCLASS_STATE = StyleManager.getInstance().getPseudoclassMask("inRange");
 
 
        @Override
        public long impl_getPseudoClassState() {
            long mask = super.impl_getPseudoClassState();
            if (isInRange()) mask |= IN_RANGE_PSEUDOCLASS_STATE;
            return mask;
        }
    }

Wie wir sehen, sind alle Metho­den «…Pseu­do­Class…» — deprecated.
Jetzt nut­zen wir statt But­ton unse­ren Ran­ge­But­ton. Und die Metho­de select­Cell sieht nun so aus:

private void selectCell(int col, int row, final boolean select){
            final Node node = getNodeFromGridPane(col, row);
            ((RangeButton)node).setInRange(select);
        }

D.h. die Ände­rung der Feld­ei­gen­schaft «InRan­ge» führt dazu, dass der Style-Trig­ger greift und die Far­be der aus­ge­wähl­ten Zel­len sich ent­spre­chend ändert.
Das ist genau das, was wir brauchen!
In Java­FX 1.7 funk­tio­niert das. In Java­FX 1.8 ist das lei­der ver­bo­ten. Der Code ist nicht mehr kom­pi­lier­bar sobald JVM 1.8 hin­zu­ge­schal­tet wird.
Was bie­tet uns dann die neue Ver­si­on an der Stelle?
Wie bereits erwar­tet, wur­den die depre­ca­ted Metho­den ent­fernt und die Archi­tek­tur ver­ein­facht. Jetzt reicht es daher aus, wenn wir fol­gen­des tun:

protected static class RangeButton extends Button {        protected final PseudoClass pcInRange = PseudoClass.getPseudoClass("inRange");
 
 
        public RangeButton(){
            getStyleClass().add("MyCell");
        }
 
 
        protected final BooleanProperty inRange = new BooleanPropertyBase() {
 
 
            @Override
            protected void invalidated() {
                pseudoClassStateChanged(pcInRange, getValue());
            }
 
 
            @Override
            public Object getBean() {
                return RangeButton.this;
            }
 
 
            @Override
            public String getName() {
                return "inRange";
            }
        };
 
 
        public boolean isInRange() {
            return inRange.get();
        }
 
 
        public void setInRange(boolean value) {
            inRange.set(value);
        }
    }

Alles funk­tio­niert wie bisher.
Man kann den Code noch etwas vereinfachen…:

protected static class RangeButton extends Button {
        protected final BooleanProperty inRange;
        public RangeButton(){
            getStyleClass().add("MyCell");
            final PseudoClass pcInRange = PseudoClass.getPseudoClass("inRange");
            inRange = new SimpleBooleanProperty();
            inRange.addListener(new ChangeListener() {
                @Override
                public void changed(ObservableValue<? extends Boolean> observable, Boolean oldValue, Boolean newValue) {
                    pseudoClassStateChanged(pcInRange, newValue);
                }
            });
        }

…und die Metho­de ent­spre­chend ändern:

private void selectCell(int col, int row, final boolean select){
            final Node node = getNodeFromGridPane(col, row);
            ((RangeButton)node).inRange.setValue(select);
        }

Zusam­men­fas­sung: Mit Hil­fe der beschrie­be­nen Lösung auf Java­FX ist es mög­lich, spe­zi­el­le user­be­zo­ge­ne Eigen­schaf­ten der Kom­po­nen­ten zu erstel­len und die­se mit den Styles zu ver­knüp­fen,. Das ist beson­ders bequem, wenn die Anfor­de­rung besteht, die Busi­ness­lo­gik kom­plett von der GUI zu abstrahieren.

Bei der Ent­wick­lung einer Soft­ware sind Tests zur Qua­li­täts­si­che­rung ein sehr wich­ti­ger Arbeits­ab­schnitt. Hier­bei wer­den ver­schie­de­ne Sicher­heits­aspek­te einer erstell­ten und wei­ter­ent­wi­ckel­ten Soft­ware durch unter­schied­li­che Sicher­heits­an­for­de­run­gen berück­sich­tigt. Dabei spie­len Tests im Risi­ko­be­reich, ein mög­li­ches Key­word-Dri­ven Tes­ting oder Data Dri­ven Tes­ting mit ver­schie­de­nen Ver­fah­ren und Test­stu­fen eine wich­ti­ge Rol­le. Die­se Tests wer­den stets vor einer end­gül­ti­gen Abnah­me und Frei­ga­be zur Nut­zung durch­ge­führt. Im Rah­men der Qua­li­täts­si­che­rung wird dabei zwi­schen ana­ly­ti­schen und kon­struk­ti­ven QS-Maß­nah­men unter­schie­den. Wei­ter­le­sen

Samm­lung der sta­tis­ti­schen Infor­ma­tio­nen über die Dokumente

In einem Doku­men­ten­ver­wal­tungs­sys­tem wer­den in der Regel Ver­trä­ge, Ver­si­che­run­gen, Rech­nun­gen und Bele­ge, E‑Mails und Faxe unter­ge­bracht und nach Wich­tig­keit sor­tiert. Wird ein Work­flow Manage­ment ein­ge­führt, wer­den die Arbeits­ab­läu­fe, die in einer Orga­ni­sa­ti­on eta­bliert sind, even­tu­ell auch orga­ni­sa­ti­ons­über­grei­fend fest­ge­legt. Dies setzt aber vor­aus, dass die Pro­zess­ab­läu­fe schon vor der Ein­füh­rung des Sys­tems fest­ge­legt und ana­ly­siert wer­den. Aus die­sem Grund ist eine Fest­le­gung der Work­flows erfor­der­lich, auch für die Abläu­fe der elek­tro­ni­schen  Bear­bei­tung. Erst wenn alles fest­ge­legt ist, kann auch die Fest­le­gung der daten­schutz­recht­li­chen Sicher­stel­lung der Bear­bei­tungs­we­ge garan­tiert wer­den. Erst wenn die kom­plet­te Bear­bei­tung elek­tro­nisch durch das Work­flow-Manage­ment gesteu­ert wird, sind die Arbeits­ab­läu­fe vor der Nut­zung die­ses Sys­tems hervorzuheben.

Wel­che DMS Soft­ware wird auf dem Markt angeboten?

Es bie­ten sich unter­schied­li­che Soft­ware-Sys­te­me für die Doku­men­ten­ver­wal­tung an. Zum einen sind es die kom­mer­zi­el­len Soft­ware­an­ge­bo­te, zum ande­ren gibt es die frei­en Soft­ware Sys­te­me für DMS. Die­se bie­ten sich als gebüh­ren­freie Open-Source Lizen­zen an. Die freie Soft­ware kann von jedem Unter­neh­men selbst instal­liert und genutzt wer­den. Es gibt aller­dings auch Anbie­ter, die sich auf die­se freie Soft­ware spe­zia­li­siert haben und auf der Basis der frei­en Soft­ware Dienst­leis­tun­gen erbrin­gen, die wie­der­um ihrer­seits kos­ten­pflich­tig sind. Bei den frei­en Sys­te­men ist vor­teil­haft, dass die­se den Bedürf­nis­sen des Anwen­ders ange­passt wer­den kön­nen und Feh­ler auch auto­ma­tisch beho­ben wer­den kön­nen — dadurch kann das Inves­ti­ti­ons­vo­lu­men um ein Viel­fa­ches gesenkt wer­den. Das so frei­wer­den­de Bud­get kann für wich­ti­ge­re Anpas­sun­gen genutzt wer­den. Es ste­hen fol­gen­de Soft­ware Sys­te­me zur Verfügung:

Freie Soft­ware Programme

Alfres­co ist eine Com­mu­ni­ty Edi­ti­on, Ago­rum core — open,
Bit­farm-Archiv, Logi­cal­DOC ist eben­falls eine Com­mu­ni­ty Edition,
Nuxeo EP, PLM­WORX, Open-Xchange

Die Kom­mer­zi­el­len Soft­ware Programme

Alfres­co (Enter­pri­se Edi­ti­on), Ago­rum core (Pro), BSCW, doti­ga, Docu­ment Con­trol Center
Faba­soft Folio, Elek­tro­ni­scher Leitz Ord­ner, Logi­cal­DOC (Enter­pri­se Edi­ti­on), Main Pyrus DMS,
Micro­soft Share­Point Ser­ver besitzt nur Teil­funk­tio­nen eines DMS, IBM File­Net, Xerox DocuShare

Soll­te man sel­ber eine DMS-Soft­ware ent­wi­ckeln oder bes­ser eine bereits bestehen­de Soft­ware nutzen?
Wenn man die Soft­ware-Ent­wick­lung beherrscht, steht dem sicher­lich nichts im Wege, aber in der Regel bie­tet sich eine güns­ti­ge und anpass­ba­re DMS Soft­ware durch­aus an. Freie Soft­ware bie­tet sehr vie­le Vorteile.
Es besteht aber auch die Mög­lich­keit, sich eine eige­ne Soft­ware von einem Unter­neh­men bezie­hungs­wei­se einem Soft­ware-Ent­wick­ler erstel­len zulas­sen. Die­se kann dann natür­lich auch genau auf die Bedürf­nis­se und die Arbeits­ge­wohn­hei­ten des Unter­neh­mens ange­passt wer­den. So müs­sen sich die Mit­ar­bei­ter nicht umstel­len und kön­nen ihre gewohn­ten Arbeits­wei­sen bei­be­hal­ten. Das wie­der­um ist aber auch mit den frei­en Soft­ware Sys­te­men mög­lich. Letzt­lich ist es eine ech­te Kosten-Nutzen-Frage.

Fort­set­zung folgt.