flashpixx
-
Gesamte Inhalte
8.302 -
Benutzer seit
-
Letzter Besuch
Inhaltstyp
Profile
Forum
Downloads
Kalender
Blogs
Shop
Beiträge von flashpixx
-
-
also ich soll laut meinem Chef eine Datenbank erstellen die als Werkzeug dienen soll um damit unsere Netzwerkstruktur besser darstellen zu können und das Zentral an einem Ort alle wichtigen Daten gespeichert sind. Derzeit verstreut auf mehreren Excel Listen! Wie z.B. alle Switche mit dazugehörigen VLAN's, Jede einzelne Portbelegung auf den Switchen, alle im Netzwerk befindlichen Geräte. Und das alles mit einer grafischen Benutzeroberfläche um schnell und effektiv Daten einzutragen und zu suchen!
Dafür gibt es fertige Programme, mir fällt kein rationaler Grund ein, das als FISI selbst zu programmieren.
-
Hallo,
zunächst einmal ein gutes neues Jahr.
Ich habe folgendes Problem, ich möchte ein Powershell Script erstellen, was einen User auf einem Rechner anlegt, dazu das Homeverzeichnis und in diesem dann ein Javaprogramm ablegt, welche als Dienst ausgeführt wird.
Für mich ist die Powershell aktuell neu, da ich aus der Unixwelt komme.
Mein aktueller Ansatz sieht so aus:
# Script muss mit mehr Rechten ausgeführt werden "Set-ExecutionPolicy RemoteSigned" # Parameter sind Benutzername und Jenkins Secret Key Param([Parameter(Mandatory=$true)][string]$Username, [Parameter(Mandatory=$true)][string]$Secret) # Prüfung, ob der User aktuell Administratorrechte besitzt #If (-NOT ([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole] "Administrator")) #{ # Write-Error("Administratorrechte sind notwendig") # Break #} # Prüfe ob Java installiert ist $javafound = $false $keys = Get-ChildItem HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall $items = $keys | Foreach-Object { Get-ItemProperty $_.PsPath } foreach($item in $items) { if ($item.DisplayName -like "Java *") { $javafound = $true break } } if (!$javafound) { Write-Error("Java wurde nicht gefunden, bitte installieren!") Break } # Serverobjekt erzeugen, um Zugriff auf den lokalen Rechner zu erhalten [ADSI]$server = "WinNT://$(get-content env:computername)" # erzeuge User mit zufälligem Passwort, wobei der User das Passwort nicht ändern kann und es nicht abläuft, # prüfe ob User erst existiert und lege danach HomeDir an $localUsers = $server.Children | where {$_.SchemaClassName -eq 'user'} | foreach {$_.name[0].ToString()} foreach($item in $localUsers) { if ( !$Username.CompareTo($item) ) { Write-Error("Benutzername $Username existiert bereits!") } } $chars = [Char[]]"abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@$%&/()=?" $pass = ($chars | Get-Random -Count 16) -join "" #$userhome = "\\$(get-content env:computername)\Home$\$Username" $user = $server.Create( "User", $Username) $user.Put( "Description", "Jenkins Slave User Account" ) $user.SetPassword( $pass ) $user.UserFlags = 64 + 65536 $user.SetInfo()Das Script soll sowohl auf einem Windows Desktop System laufen, ebenso wie auf einem Server OS. Ich scheitere aktuell daran, dass ich nicht weiss, wie ich das Userhomeverzeichnis erstellen kann.
-
Jetzt stellt sich mir die Frage, ob es durch Verwendung dieser XSD-Dateien evtl. irgendwelche Vorteile gibt.
Generiere ich mit XSD.exe aus den XSD-Dateien Klassen, dann fehlt mir irgendwie jegliches Vererbungskonzept.
Man kann in XSD durchaus ein "Vererbungskonzept" erstellen (siehe XSD and polymorphism - Stack Overflow)
Mir ist hier der Vorteil von XSD-Verwendung nicht klar. Wenn es denn überhaupt einen gibt!?
XML Schema ist dafür gedacht, dass man die Struktur eines Dokumentes beschreibt und mit Hilfe des XSD diese Struktur validieren kann. Aufgrund dessen kann man dann auch direkt aus der XSD Klassencode genieren, so dass Änderungen in der Struktur durch automatische Prozesse übertragen werden können
-
XSD liefert einen strukturierten Datensatz und je nach Sprache gibt es dann passende Proxyklassen, die das Lesen/Erzeugen der XML direkt durchführen.
Generell würde ich die Frage bezügl Overhead nicht so pauschal angehen, denn es stellt sich die Frage nach den genauen Anforderungen an das System, z.B. Matrix Daten als XML zu transportieren ist sicherlich nicht so sinnvoll, wohin gegen eine Baumstruktur durchaus dafür gut geeignet ist
-
Ich habe das eigentlich ziemlich abstrakt gemacht. Ich habe eine Oberklasse mit den Membern "name", "label", "isRequired" usw., die schließlich jedes Feld hat.
Nein Du hast nicht abstrakt gearbeitet, denn Dinge "isRequired" gehören in die Datenbank (not null) oder wenn sie im der Darstellung verwendet werden, in den View des MVC Pattern. Du hast hier etwas undefiniertes gebaut und zusätzlich sind die Namenskonventionen schlecht gewählt, denn wenn eine Variable "DBTable" nennt, dann ist das die physische Verbindung zu der Datenbanktabelle und hat mit der Ausgabe nicht zu tun (MVC Pattern wäre das dann das Modell).
Davon leite ich die anderen Felder ab, diese haben dann nur noch die zusätzlichen Methoden für die spezifischen Dinge. Außerdem habe ich es ja auch gekapselt. Ich habe ja zB die Methode GetHTMLForm(), diese gibt das Formular aus. So kann ich jedes Feld*.getHTMLForm(), ohne mich darum kümmern zu müssen, was in der Methode tatsächlich passiert.
s.o. das ist nicht Sache des Feldes sondern des Views.
Also wenn man dann mal absieht, dass ich die Ausgabe nicht von der Logik trenne (zB über die von dir vorgeschlagenen Renderklasse), habe ich das doch mit ganz ordentlichem OOP gemacht? Natürlich kann ich das auch in eine Renderklasse packen (Renderer.render(Field field)) und dann je nach Objekt die enstprechenden Methoden (((FieldInt) Field.getMin());, field.getLabel(), ...) aufrufen.
Nein, die Überprüfung von min / max Werten macht mittels Check-Constraints auf der Datenbank, d.h. das Modell kann bei falschen Eingaben eine Exception werfen oder man kann innerhalb des Controllers diese Überprüfung machen. Beides hast Du nicht gemacht.
Es geht darum, dass mir MySQL bestimmte Datentypen zur Verfügung stellt, mit denen ich meine Tabellen abbilden muss, da ich meine Spalten nur mit diesen Typen deklarieren kann.
Und was hat das mit dem problem zu tun, die Typenconfertierung zwischen Datenbank und Java geschieht mittels JDBC bzw. Prepare-Statements, somit wird ein Javatyp direkt auf den dazu passenden mySQL Datentyp gemappt (vice versa). Das was Du da machst, ist überflüssig, da es direkt von der Architektur geliefert wird.
Dein Architektur ist ineffizient und nicht sauber gekapselt und letzteres ist definitiv ein Kriterium für OOP.
-
Es kam aber mittlerweile schon wieder eine neue, die angeblich von mir ist. Wie bekomme ich den E-Mail Header?
Im Normalfall kann Dir der Client den Header anzeigen bzw. schau Dir Dir die EMail im Plaintext an. Der Aufbau des Header kannst Du in der passenden RFC nachlesen
Es gibt bestimmt auch User-Friendlier Wege, oder?
Dein Mailclient
-
Für mich liegt der Nutzen von Spring darin, mir boilerplate abzunehmen. Und gerade Java ist voll von boilerplate und ceremony code. Spring ersetzt keine Architektur und es hilft auch keine zu erstellen: aber es hilft sie umzusetzen. Gerade Spring-Data (in meinem Fall hauptsächlich JPA) hilft, sich auf das Wesentliche, sprich die Businesslogik zu konzentrieren.
Ich bin den letzten 10 Jahren gerade damit sehr vorsichtig geworden, denn häufig werden genauso argumentiert, dass diese Frameworks eben Arbeit für Boilerplate abnehmen. Wenn man sich aber den Code dann später anschaut sieht man häufig, dass weder die Logik ordentlich ist, noch der Boilerplatecode, oft sieht man, dass die Logik um den Boilerplate Code herum gebaut wurde, weil das Framework eben gewisse Funktionalität, die man braucht, nicht so unterstützt, wie man sie braucht. Gerade bei Java Entwickeln ist der Hang zu unsagbaren komplexen Frameworks mit sehr seltsamen API Strukturen groß. Es wird immer argumentiert, dass man ein OOP Konzept hat, aber wenn man schon einfachste Enums noch über Objekte kapselt oder argumentiert, dass mein Getter / Setter brauchst und alles mittels public / private / proteced machen kann, dann ist dies IMHO am Thema vorbei.
Sauberes und vor allem klares Architekturkonzept ist immer Pflicht, ebenso Refactoring. Wenn man im Konzept die Möglichkeit hat ein Framework zu verwenden, dann muss man auch klar definieren wo die Grenzen des Frameworks sind und was man von dem Framework erwartet (bzw. nicht erwarten kann). Manchmal macht es durchaus Sinn die Funktionalität, die man braucht selbst zu schreiben, da sich der Code dann in die komplette Architektur besser integriert.
@back to topic: Wie man aber in dem Post von pr0gg3r sieht, ist aber genau hier der Punkt. Das Konzept ist schon falsch gewählt, eine andere Technologie wird die Probleme nicht lösen. Ebenso stelle ich mal die konzeptionelle Frage, warum muss man für eine Webanwendung z.B. Java nehmen? Ich brauche ein System wie Tomcat, habe dann evtl noch einen Webserver der als Proxy fungiert, d.h. 2 Serverdienste, die beide Wartung (und damit Kosten) verursachen. Als normler User kann ich nurr begrenzt in die Konfiguration des Tomcat eingreifen. Warum kann man nicht für diesen Fall einen Apache mit PHP verwenden und dann kann jeder User seine Scripte im Homeverzeichnis ablegen und sie werden direkt ausgeführt.
Java selbst hat in den letzten Jahren massive Sicherheitlücken aufgewiesen. Somit für mich keine gute Wahl für Webanwendungen.
Der Ansatz ist saubere Problemdefinition, danach die passende Technologie auswählen und dann umsetzen.
-
Du hast recht, ich sollte lieber einer Renderklasse "irgendwas" übergeben und diese entscheidet dann selber, um was es sich handelt. Das gibt dann neue Probleme, zB mache ich aus einem Array eine Liste mit Checkboxen oder Radioboxen? Dann muss ich hierfür ja wieder eine eigene Klasse erstellen, die vom Typ Array abgeleitet ist und aufgrund dessen die Entscheidung treffen.
Wieso das? Das ist doch völlig inkonsistent. Die Renderer Klasse weiss, was Sie mit den Daten anfangen kann, sie bekommt einfach das Datenobjekt übergeben und holt sich aus dem Datenobjekt das was sie braucht.
Ich habe mein allgemeines Feld, das einen Namen beinhaltet, welcher der Tabellenspalte in der Datenbank entspricht und ein Label, welches ich in der Ausgabe verwende, beinhaltet. Das soll schließlich jedes Feld haben. Dann habe ich davon abgeleitet mein Feld für Integer, welches einen Min- und Max-Wert haben kann, mein Feld für String, welches einen Member für die Anzahl der Zeichen hat usw. Ich habe diese Lösung gewählt, weil ich dann einfach meine ArrayList<Field> (als Member zu jeder Tabellenausgabe) habe und dort dann möglichen Field*reinschmeißen kann. Fand ich bisher eigentlich auch garnicht so doof:
Das ist total gruselig. Der Code z.B.
mitarbeiter.addField(vorname);
würde implizieren, dass Du auf Datenbankebene eine Spalte "vorname" hinzugfügst, denn mitarbeiter ist vom Typ DBTable. Das ist von der Benennung und Struktur völlig inkonsistent und unverständlich.
Wenn Du MVC machen willst, dann stellt der Controller die Verbindung zwischen Datenmodell und View dar und wenn man das ordentlich macht, dann kann man hier einen abstraktes Binding zwischen Datenmodell & View erzeugen.
Das was Du machst ist für mich "ganz übles Coding", das ich eher einem Azubi noch zugestehe. Wenn ich den Code sehe, dann zeigt das für mich, dass Du nicht wirklich verstanden hast wie OOP funktioniert, siehe http://www.approximity.com/rubybuch/node61.html insbesondere Kapselung und Abstraktion sind bei Dir nicht erkennbar, denn Du mischst Strukturen. Im Grunde ist es bei Dir eine funktionale Programmierung, die Du mit OOP versucht hast auf zu hübschen. Sorry für die harte Kritik, aber ohne ein sinnvolles Architekturkonzept mit entsprechendem OOP-Design wirst Du immer Probleme haben. Du solltest erstmal bei den Designfragen beginnen und erst danach die Technologie auszuwählen.
-
Eine Notwendigkeit der Unterklassen sehe ich vor allem beim Formular für die Dateneingabe und -bearbeitung: ein Boolean wird anders ausgegeben (Checkbox) als ein Join (Select) oder ein String (Text) oder Text (Textarea) oder ein Datum. Bei dem Join muss ich außerdem erst noch die verzweigten Daten laden. Solche Dinge werden von meinen Field*-Klassen hauptsächlich erledigt.
Das ist doch schon ein Designfehler, denn Deine Datenklasse hat mit der Ausgabe nichts zu tun. Die Datenklasse kümmert sich nur darum, dass die Daten inhaltlich korrekt sind und eine Renderer-Klasse kümmert sich um die Darstellung. Z.B. ist die Darstellung in einem XML Dokument anders als in einem HTML Dokument. In Deinem Fall müsste die Datenklasse alle diese Unterscheidungen implementieren.
Die Datenklasse kümmert sich nur um die semantisch korrekte Darstellung der Daten z.B. eine Länge darf nicht negativ sein und sie sollte weitere Abhängigkeiten, die sie hat, auflösen können.
Eine Rendererklasse bekommt dann eine Datenobjekt und sorgt dann dafür, wie dieses Datenobjekt dargestellt wird. Wenn man klassisch MVC macht, dann hat man noch einen Controller, der eben ggf Eingabedaten validiert.
Ich versuche über meine Unterklassen die häufigsten Fälle abzudecken.
Das klingt mir sehr danach, dass Deine Architektur fehlerhaft ist, denn Du versucht mit "Unterklassen" "häufige Fälle" abzudecken. Mir scheint Du das das Prinzip von Vererbung nicht richtig verstanden, denn eine abgeleitete Klasse stellt eine Spezialisierung dar, "häufige Fälle" dagegen eine Generalisierung, d.h. das kann nicht richtig funktionieren, da Du hier ja genau versucht ein Komplement zu implementieren.
Das von mir vorgestellte Konzept ist sehr generisch, aber benötigt entsprechende Kenntnisse in OOP, d.h. wenn Du OOP nicht wirklich sicher beherrschst, solltest Du die zuerst nacharbeiten. Es ist absolut fahrlässig, wenn Du die (theoretischen) Konzepte nicht beherrscht und dann versuchst mit einer neuen Technologie das ganze zu lösen, das wird letztendlich zu extrem ineffizienter Arbeit & Code führen. Ich habe aufgrund dieses Posts das Gefühl, dass Du große Designfehler in Deiner bestehenden Anwendung hast und diese wirst Du mit einem NoSQL Ansatz nicht lösen können.
-
Ja, wobei ich halt "_rev" = "history" benannt habe und dort ist dann im Grunde der komplette Datensatz wieder drin und "id" heißt bei allen MongoDB Collections "_id", d.h. der PK heißt auf jeder Collection gleich. Ein Trick durch die Arrayüberladung ist, dass ich automatisch Felder, die nicht existieren "null" setze, d.h. wenn ich mein Datensatzobjekt habe und dort $item["blub"] mache und das Feld "blub" nicht existiert wird immer null geliefert, damit habe ich keine Exception, dass ein Key nicht existiert, da ich die Existenz implizit mache. Es verschlankt den Code, da ich nicht erst prüfen muss, ob das Feld existiert und welcher Wert drin steht. Ich kann halt direkt auf den Wert prüfen. Deine Struktur mittels Feldklasse würde ich nicht unter Java machen, weil Du blähst den Code damit sehr auf. Bei MongoDB kannst Du direkt aus dem JSON Objekt ein Javaobjekt machen (siehe JSONObject) und dieses würde ich durch eine allgm Wrapperstruktur kapseln, die Du dann z.B. von HashMap ableiten kannst, damit kannst Du auf die Felder via Key zugreifen. OOP ist zwar schön, aber zuviel OOP bläht auf und leider tendiert man in Java gerne dazu. Je weniger Code Du schreiben musst, um so besser, denn Du erzeugst weniger Fehler und man kann sich leichter einlesen. Ich brauche durch die Arraystruktur nicht so etwas wie "getName" oder "setName", sondern ich mache nur "$item["name"]". Die Überprüfung ob da wirkliche ein String drin ist, geschieht dann in der überladenen ArrayAccess Methode und diese reicht die Daten an die Parentklasse nach der Überprüfung weiter. Ich habe somit immer _nur eine_ Methode um Daten zu holen bzw. zu setzen und das für alle Entities der Datenbank. Für jede Entity habe ich eine Klasse, aber die Klassen sind deutlich kleiner, weil sie wirklich nur den Code enthalten müssen, der für die Entity relevant ist. Irgendwelche Feld- oder Strukturklassen gibt es bei mir nicht. Jede Entityklasse hat eine statische Eigenschaft "collectionname", in der der Collectionname hinterlegt ist, ebenso eine statische Eigenschaft, ob die Historie im Dtor erzeugt werden soll oder nicht, mein Dtor sieht dann so aus:Wenn ich das in NoSQL dann so realisiere:
{ "id": "....", "_rev": "...", "marke": "vw", "modell": "Caddy", "kennzeichen: "ab-cd-1234", "ladeflaeche": 22.3 "buchungen": [ { "mitarbeiter": "...", "von": "2013-12-12T12:00", "bis": "2013-12-14T14:00", "Grund": "Abholung Material" }, { "mitarbeiter": "...", "tag": "2013-12-15" } ] } } { "id": "...", "_rev": "...", "marke": "Audi", "modell": "A6", "kennzeichen: "ab-cd-5678", "mitarbeiter": "..." }Kann ich darauf verzichten, die Felder tatsächlich immer in der DB anlegen zu müssen. Zusätzlich müsste ich mir nicht die Queries zusammenbasteln (können mit mehreren Joins dann schon mal komplex werden) und hätte die Revisionen gleich mit dabei. Also ist es doch tatsächlich eine Überlegung wert.if ($this->m_ismodified) { if (static::$ml_history) $this->ma_data["history"] = $this->ma_data; $this->ma_data["modificationtime"] = time(); Database::save( static::$mc_collectionname, $this->ma_data ); }ma_data cachet den Inhalt des Datensatzes und der Rest sollte klar sein.
@lilith2k3: Spring ist zwar sicherlich eine nette Sache, aber man tendiert häufig mit solchen Bibliotheken zu komplexen Interfaces. Ich bin kein Freund von diesen Technologien. Man sollte zuerst eine ganz klare Definition für die Daten entwickeln und exakt die Schnittstellen und die Grenzen des Systems beschreiben und danach den Code entwickeln. Je schärfer man die Grenzen zieht um so besser. Alles was nicht definiert wurde, wird nicht codiert. Die ganzen Frameworks erzeugen oft Probleme, da sie meist nur 50-60% der Anforderungen erfüllen und man dann die restlichen Prozent händisch eh dran stricken muss, dann muss man die Version des Frameworks und des eigenen Codes abstimmen, was ebenfalls fehleranfällig ist. Für mich ist der Einsatz eines Frameworks häufig ein Zeichen, dass der Entwickler keine Lust hatte eine saubere Architektur zu entwickeln und stattdessen diese Aufgabe an das "Framework outsourced".
Allerdings kann man ein Framework in die Architektur richtig integrieren, wenn man wie oben gesagt die Grenzen sauber definiert hat und das Framework dann an diesen Grenzen einsetzt. Zuerst muss man das System so vollständig wie möglich am Besten durch einen iterativen Prozess scharf beschreiben. Entsprechende Frameworks mit ihrem Einsatzziel können mit definiert werden. Danach beginnt man die Umsetzung macht aber klare Abschnitte, nach denen man Refactored und ggf Fehler in der vormals definierten Spezifikation korrigiert.
-
Dann bräuchte ich eigentlich ja nur einen Wrapper, der mit die Klasse in JSON umwandelt und wieder zurück (ich vermute, das machst du mit deiner Parentklasse?) und brauche mich nicht weiter um die Datenbankkommunikation kümmern (wie bisher, indem ich aus jeder Klasse andere Tabellen und Spalten abfrage)?
Nicht ganz. Ich habe eine Connectionklasse, die eben die Verbindung als Singleton Struktur aufbaut und mit der meine anderen Klassen arbeiten (das Singleton ist immer Session bezogen). Die Parentklasse repräsentiert einen Datensatz, also ein abstraktes Modell des Datensatzes, in dem z.B. Felder wie owner, history etc existieren. Es definiert so etwas wie die Requirements eines Datensatzes und eben die Zugriffsrechte. Davon leite ich dann konkret ab und kann dann sagen, dass z.B. ein OU-Datensatz so etwas wie eine Adresse hat usw. In der OU Klasse ist dann z.B. hinterlegt in welche Collection physisch geschrieben wird (mittels statischem Property).
Damit erhalte ich eben ein sehr flexibels Modell, denn ich leite immer von einer Basisklasse ab, bei mir DatasetItem. Diese Klasse kümmert sich immer um die Kommunikation mit dem Datenbaninterface und sichert mir generelle Eigenschaften des Datensatzes wie Zugriffsberechtigungen. Die Ableitung spezifiziert dann lediglich weitere Teile und ich muss nur genau diese implementieren, aber nur so, dass ich aus den public Strukturen der abgeleiteten Klasse die Daten an die protected Strukturen der DatasetItem Klasse reiche.
Durch die Überladung der Array-Access Methoden brauche ich auch kein echtes MVC Pattern, denn ich habe einen Singleton Renderer, dieser bekommt ein solches Objekt und ich kann mittels instanceof prüfen zu welcher Klasse es gehört und kann direkt die Inhalte der Felder holen. Der Renderer hat dann z.B. einen Renderer für XML, einen für HTML usw. und diese bekommen dann nur ein Key-Value Array mit Daten. Analog funktioniert das Einfügen in die Datenbank, ich zerlege die ankommenden Daten anhand ihres Types (XML, HTML, ...) und erhalte ein Array, das Array wird dann der passenden Datenklasse einfach in der form dataclass::create( $array ) übergeben und ich bekomme das Datenobjekt zurück, was gleichzeitig in der Datenbank erzeugt wurde.
Zusätzlich habe ich ein Caching, denn erst der Dtor schreib physisch die Änderungen in die Datenbank. Die Parentklasse merkt sich intern, ob Eigenschaftes des Datensatzes geändert wurden und im Dtor wird dann über das Datenbankinterface wenn nötig die Verbindung aufgebaut und die Änderungen geschrieben. Dort wird dann auch die Historie erzeugt. Somit habe ich kein explizites schreiben.
-
Das Schlimmste wäre jetzt, wenn ich die Entscheider von NoSQL überzeuge, die Umsetzung dann aber nicht mehr so funktioniert, wie ich mir das vorstelle, also ich ständig Probleme habe, weil ich auf eine andere DB setze. Das möchte ich verhindern. Auf der anderen Seite ist eine Reduzierung des Codes um 80% natürlich ein überzeugendes Argument.
Vielleicht hier noch als Ergänzung, es ging bei mir darum ein "Datengrab" zu schaffen, d.h. wir haben eine Datenbank in der nicht gelöscht werden soll und gleichzeitig eine Historie der Änderungen für jeden Datensatz gespeichert wird. Unsere Wahl ist auf MongoDB gefallen, da wird ebenso zu den Daten auch noch Binärinformationen in jedem Datensatz mitführen müssen.
Da ich letztendlich mit JSON Strukturen arbeite habe ich eine Parentklasse, in der die Informationen, die bei allen Datensätzen gleich sind, abgelegt und dann durch eine Ableitung nur spezialisiert sind. Das ganze noch über Array-Access Ableitung erweitert und somit kann ich mit den Datensätzen arbeiten wie mit Arrays. Da die Datensätze selbst kaum vernetzt sind, also kaum Abhängigkeiten aufweisen bringt NoSQL da definitiv eine gute Performance. Ich kann meine Daten als eine Art ungeordnete Menge betrachten.
Das Szenario des Projektes kann mich sich recht typisch vorstellen: "Was bisher mit Excel verwaltet wird, soll nun über ein Programm realisiert werden" plus weitere Funktionen (Rechte, Revisionen, Felder die ausgefüllt werden müssen, mögliche Querverknüpfungen je nach Auswahl etc.). Das heißt, meine Struktur ist "starr".
Da Du hier Excel ansprichst, rate ich mal zu Multidimensionale Datenbank
Die Frage ist, wie sind Deine Daten inhaltlich strukturiert
-
Ich kenne NoSQL-Datenbanken bzw. habe MongoDB und CouchDB jeweils privat installiert und ein wenig getestet/angeschaut, ich bin mir jedoch nicht sicher, ob das nur ein vorübergehender Hype bzw. Trend ist oder ob sich NoSQL-Datenbanken tatsächlich etablieren werden.
Da stimme ich zwar zu, aber gegenüber RDBMS Strukturen sind natürlich die Map-Reduce-Algorithmen nicht zu ignorieren
Im Unternehmenseinsatz besteht natürlich auch immer die Frage, wie sieht die vorhandene Infrastruktur aus, wo liegt das Knowhow der Projektmitarbeiter etc., da kann man nicht einfach mal kurz die Datenbank hinter der Software ändern
Das ist ein sehr wichtiges Argument. Ich kann durchaus für beide Seiten sprechen, da ich aktuell beides benutze. In einem Projekt konnte ich durch den Einsatz einer NoSQL Datenbank den Code um 80% reduzieren und wesentlich generischer aufbauen, was dadurch zu viel einfacheren Strukturen führt (Webapplikation). In einem anderen Projekt habe ich ein klassisches RDBMS verwendet, da hier die Strukturen dies angeboten haben.
Ich denke man muss dies von Fall zu Fall individuell überdenken.
-
Sei dir aber bewusst, dass das bei einer anwachsenden Tabelle ohne Löschintervalle zu großen Datenmengen auf dem Server kommen kann. Da sollte man ggfs. direkt beim Trigger mit anbauen, um Datenmüll zu vermeiden.
Dazu ergänzend wäre es bei so etwas die Überlegung eine NoSQL Datenbank zu verwenden, da diese über die Entsprechenden Map-Algorithmen dafür ausgelegt sind sehr große Datenmengen zu verwalten. Bei NoSQL kann man die Historie in jedem Datensatz direkt mit speichern, so dass damit der Zugriff deutlich vereinfacht wird.
-
ich bin da absolut konform mit Dir insbesondere was den Datenschutz angeht.
Was ich evtl da vorschlagen würde, dass man da gar keineIRC Server benutzt sondern eben das in den Webserver integriert, Twitter macht auch nur JSON mittels REST-API über HTTP(s). Über HTTP-Auth bekomme ich dann auch direkt die Authentifizierung hin. Bei IRC sehe ich halt das Problem, dass das ggf mit dem "nicht Standardport" (also man benutzt was, was schon etwas aus der "Hacker-Szene" kommt) nicht so schön ist.
Gerade bei Geschäftsdaten würde man vielleicht doch eher so etwas wie WS-Business Process Execution Language verwenden
-
Hmmm... also ich weiß nicht, was da an Twitter so toll sein soll, dass man krampfhaft diese Lösung präferieren sollte mit dem zusätzlichen Aufwand der Verschlüsselung/Entschlüsselung.
Das Problem kann durchaus bezüglich des Ports sein, d.h. müsste man schauen ob man über den IRC Port connecten kann. Wenn das nicht geht und z.B. nut HTTP/HTTPs geht, dann brauche ich einen Wrapper, der die Kommunikation ermöglicht
Der Vorteil dieser Lösung ist in meinen Augen, dass man komplett unabhängig von irgendwelchen öffentlichen Infrastrukturen ist (ansonsten kann es mal sein, dass Twitter z.B. nicht erreichbar ist, wenn es angegriffen wird.
Das Problem habe ich bei einem IRC Server auch, sobald er von außen erreichbar ist.
Natürlich müsste so ein Server gewartet werden, aber mir persönlich wäre es s lieber, als die Abhängigkeit von einem öffentlichen Dienst, bei dem ich drauf vertrauen muss, dass es alle User erreicht und keinerlei Einfluss darauf habe, wenn man irgendetwas nicht so geht, wie es soll.
Die Wartung ist von den Betriebskosten nicht zu unterschätzen.
-
Daraus kann man dann schon einiges über die Kommunikation ablesen.
Ich würde wirklich zu Public-Key-Verschlüsselungsverfahren tendieren, d.h. die Timeline kann öffentlich sein und die User bekommen einen Schlüssel, um die Nachrichten zu entschlüsseln, d.h. Du kannst ein gruppenbasiertes Nachrichtensystem über einen öffentlichen Kanal durchführen.
Ich würde für die Verschlüsselung GnuPG - Libraries verwenden und lediglich einen kleinen Client entwickeln, um Nachrichten zu empfangen. So wie ich es verstehe hast Du ja keine bidirektionale Kommunikation. Jeder Client hat dann eben für jede Gruppe einen Schlüssel für die Entschlüsselung hinterlegt und der Poster des Tweets verschlüsselt die Daten. Der Client liest automatisiert die einkommenden Tweets und versucht sie zu entschlüsseln, wenn dies nicht funktioniert, ignoriert er den Tweet, andernfalls zeigt er ihn an, damit sieht der User nur die Nachrichten, für die er authentifiziert ist
-
Kann man das eigentlich überhaupt irgendwie so beschränken, dass das nur diejenigen dann sehen könnten, die es angeht und die Daten auch nicht "aus Versehen" durch einen Retweet an alle oder so dann an die Öffentlichkeit gelangen?
Tweets bzw die gesamte Timeline können als privat markiert werden.
Alternativ könnte man die Tweets auch noch verschlüsseln, so dass nur Leute, die einen speziellen Schlüssel haben, die Tweets lesen können, d.h. man hätte einen Gruppenbasierten Schlüssel und ein Shared-Medium.
Bei Twitter wäre da definitiv der Vorteil der entsprechenden Unterstützung durch Frameworks und eben der hohe Verbreitungsgrad.
Wenn ich nicht irre gab es hier im Forum mal eine Abschlussarbeit für genau diesen Fall, also evtl man denjenigen anschreiben
-
Wie wäre es mir Twitter?
-
Ich habe die Werke von Scott Meyers, aber ich finde die eigentlich nicht so einsteigerfreundlich, es ist doch schon eher etwas für Leute, die die Grundlagen können
-
Geht es nun um make oder C++?
Es geht primär um C++, aber ich wenn ich C++ Code habe, muss ich diesen ja übersetzen d.h. ich denke eine kurze Einführung in Buildsysteme wäre durchaus sinnvoll insbesondere damit man den Compile- und Linkprozess versteht
-
Da du Make angeführt hast denke ich das du es unter Unix lernen willst?
Naja nicht nur, ich nutze selbst SCons, aber auch CMake. Ich finde für einen Anfänger es sehr schön zu sehen wie make arbeitet.
-
Hallo,
ich suche ein (paar) Einsteigertutorials für C++ (für einen Studenten). Ich benutze zwar gerne die Werke von Balzert um die OOP darzustellen, aber schön wäre auch so etwas wie Compiler, Linker, statisches / dynamischen Linken, Buildscripte (make), etc.
Hätte jemand evtl eine Empfehlung (Webseite / Buch) ?
Danke
-
Gibt Dir das [i]Home[/i]-Verzeichnis für den aktuellen Benutzer.
Das nützt mir aber nichts, ich brauche das HomeDir des neu angelegten Users.
Powershell User anlegen für Dienst
in Skript- und Webserverprogrammierung
Geschrieben
Vielen Dank für die Fragen.
Mir reicht ein lokaler User, da nicht jeder Rechner zwingend in einer / der Domäne sein muss, d.h. ich möchte, dass der User unter dem der Dienst läuft immer nur lokal existiert.
Ja, ich möchte ersten den lokalen User erzeugen, danach möchte ich das Homeverzeichnis unter C:\Users anlegen, dafür dann die passenden Owner & Rechte setzen (der User muss in dem Verzeichnis Schreibrechte haben), in das Homeverzeichnis lade ich dann mit
meine Jar Datei, die aber nicht von dem User überschrieben werden darf und zum Schluss möchte ich dann folgendes CL-Kommando als Dienst hinterlegen:Dazu direkt die Frage: Ist mein gedachtes Vorgehen sinnvoll?
Danke für den Hinweis, das hatte ich vergessen
Mir geht es nur darum, dass ein User ohne Probleme das Script ausführen kann und nicht erst viel an Berechtigungen erstellen muss. Der User soll das Script ausführen und dort alle benötigten Infos eingeben, das Script meldet dann entweder, dass man als User nicht die notwendigen Rechte für die Konfig hat oder es legt die Daten wie oben beschrieben an.
Es soll kein Schutz sein, sondern ich möchte wenn das Script ausgeführt wird, zuerst prüfen, ob der User der das Script startet alle benötigten Rechte hat. Meines Wissens brauchte ich für das Erzeugen des Homeverzeichnisses und der Dienstekonfiguration lokale Adminrechte.