Shared posts

09 Jul 09:35

the next big thing: Unter Quarantäne: Tests isoliert ausführen

Reine Geschäftslogik zu testen ist einfach. Das Testen von Ressourcenzugriffen hingegen ist weitaus schwieriger, da man stets einen isolierten und reproduzierbaren Kontext erzeugen muss. Das Node.js-Modul isolated hilft, das Dateisystem zu isolieren.
08 Jul 06:46

Identität ist eine Aufgabe

by Gastbeitrag

Der Artikel stammt von Katharina Ohana (Gastautorinnen) und ist ein Auszug aus ihrem Buch “Gestatten: ICH: Die Entdeckung des Selbstbewusstseins”. © Katharina Ohana

Die meisten Menschen zweifeln durchaus an der Vernunft der anderen, aber selten an ihrer eigenen. Mittlerweile hat die moderne Gehirnforschung immerhin zweifelsfrei bewiesen, wofür Sigmund Freud noch ausgelacht oder beschimpft wurde: Unsere Vernunft mischt sich in unsere Entscheidungen nur wenig ein. Der größte Teil unserer Handlungen wird von abgespeicherten Erfahrungsmustern und Gefühlen bestimmt, die uns in unserer Kindheit widerfahren sind. Besonders unsere Eltern beeinflussen mit ihrer Art von Liebe, ihrem Verhalten und ihrer Weltsicht für den Rest unseres Lebens unser Denken und Fühlen – und wir merken diese Fremdbestimmung nicht einmal. Unser Bewusstsein täuscht uns Freiheit und Selbstbestimmung vor, dabei strebt unser Unterbewusstsein immer nur nach Zuwendung und Bestätigung. Denn unsere Sehnsucht nach Liebe und Anerkennung ist die Grundlage unseres Menschseins.

Der Mensch ist ein soziales Wesen und die Liebe in all ihren Varianten ist die Anziehungskraft zwischen den Menschen. Sie ist der Kitt jeder Gemeinschaft und lehrt uns unseren Wert: Es ist uns so wichtig, was andere von uns denken, weil wir ihre Zuwendung und Anerkennung, ihre Liebe für unser Überleben brauchen.

Unser Selbstwertgefühl ist der Spiegel erfahrener Liebe und Zuwendung. Und es ist der Schlüssel zu unserer geistigen und körperlichen Gesundheit, unserem Glück. Wenn wir um unsere Stärken wissen, unseren Wert kennen, ist unser Selbstwertgefühl stabil und nicht so schnell angreifbar; denken wir aber, wir müssten „besser“ sein, um geliebt zu werden, um ein anerkanntes Mitglied einer Gemeinschaft zu sein, haben wir ein schlechtes Selbstwertgefühl und empfinden uns als minderwertig. Wir versuchen Dinge zu tun und zu besitzen, die als „gut“ gelten und uns liebenswerter und wertvoller machen sollen. Wir versuchen angepasst zu sein oder reich zu werden, machen Überstunden oder gehen ins Fitnessstudio – und hoffen auf den Lohn der Anerkennung und Bewunderung. Oder wir versuchen es mit Tricks: Wir schreiben die Hausaufgaben ab, stellen falsche Fotos von uns in die Partnerbörsen des Internets und leihen uns einen Porsche.

Auch altruistisches Verhalten verschafft uns Bestätigung: Die Liebe, die wir geben, festigt unsere Position in der Gruppe und stärkt ihren Zusammenhalt. Wir unterdrücken unsere Bedürfnisse zu Gunsten anderer Gruppenmitglieder und erhoffen uns durch unsere Selbstbeherrschung den langfristig größeren Erfolg – für uns selbst. Dazu müssen wir lernen mit Frustrationen umzugehen. Und wenn wir häufig auf die Befriedigung unserer Bedürfnisse, auf Aufmerksamkeit und Zuwendung verzichten und trotzdem nicht beachtet werden, entsteht aus der Frustration Aggression. Diese Wut, als Negativ der Liebe, gefährdet aber unseren Erfolg in der Gemeinschaft: Wir sind auf die wütend, von denen wir Zuwendung erwarten und sie nicht bekommen.

Unser Wertgefühl und unser Verhalten gestaltet sich somit zwischen Bedürfnisbefriedigung und Bedürfnisunterdrückung, zwischen Selbstbehauptung und Empathie, der Sehnsucht nach Liebe und ihrer Macht über unser Glück.

Liebe ist kein zufälliger Überschuss der Evolution, sondern die Motivation hinter all unserem Handeln. Sie lässt uns im optimalen Fall das Leben als wertvoll erscheinen: Wirkliche, erfüllende gegenseitige Wertschätzung, als tiefes Gefühl der Anerkennung und der sozialen Verbundenheit gibt unserem Leben Sinn. Aber Liebe, als erfüllendes Miteinander, muss man geben und nehmen lernen.

Wir klammern uns an die romantische Idee, die Liebe wäre eine Himmelsmacht, die uns Menschen von unseren irdischen Erfahrungen entbindet. Jedoch werden wir, je tiefer und intensiver die Beziehung zu einem anderen Menschen ist, um so mehr von den Verhaltens- und Emotionsmustern aus unserer Kindheit ferngesteuert: In unseren Partnerschaften lieben wir den Anderen immer mit unserer gelernten, unbewussten Bindungserfahrung.

Tief in unserem Inneren ist ein Teil von uns immer noch das Kind, das hofft, dass man seine Not erkennt, ihm zeigt, dass es wertvoll und wichtig ist. Wir erwarten als Erwachsene von unserem Partner, dass er uns bedingungslos liebt, egal wie schwach wir sind, wie wir aussehen, was wir anstellen – so wie unsere Eltern es hätten tun müssen, als wir Kinder waren. Wir suchen im anderen unsere Eltern und bemühen uns auf die gleiche Art und Weise um seine Liebe, wie wir uns um die Liebe unserer Eltern bemüht haben.

Leider bekommen wir daher (meist) auch nur die gleiche Art von Liebe. Bei allen Menschen finden sich im Umgang mit dem Partner, Freunden oder Kollegen Reste dieser kindlichen unreifen Liebe und daraus hervorgehender alter Sehnsüchte. Diese Liebe sucht in den Augen der anderen immer die schmerzlich vermisste Wertschätzung: Der andere bestimmt mit seiner Zuwendung maßgeblich das eigene Selbstwertgefühl und Wohlbefinden – genauso wie es einstmals die Eltern taten.

Jede Beziehung zu einem Menschen mit infantilen Bestätigungs- und Liebesforderungen spiegelt aber auch die unreifen Anteile der eigenen Persönlichkeit. Die Liebesmuster der Partner passen zueinander wie Puzzleteile: Die emotionalen Muster ergänzen sich in ihrem Kampf um Anerkennung und Aufmerksamkeit. Zu einer unreifen Beziehung gehören immer zwei.

„Die Hölle, das sind die anderen“, schreibt Jean Paul Sartre und man könnte hinzufügen … weil sie uns unseren Wert nicht so bestätigen, unsere Bedürfnisse nicht so befriedigen, wie wir es uns wünschen. Jeder, der in seiner Kindheit nicht genug Wertschätzung und gesunde Liebe erfahren hat, dessen Leben ist bestimmt von der Suche danach. Sie wird zur Priorität, zur treibenden Kraft und sie behindert unsere Entfaltung: Ein schlechtes Selbstwertgefühl macht unfrei und unglücklich.

Unser Selbstwertgefühl ist ein Trick der Evolution, um unser Überleben zu sichern. Vor seinem Hintergrund versuchen wir, vom Anfang bis zum Ende unseres Lebens, Gut und Schlecht zu unterscheiden, alles für unseren Vorteil zu bewerten und zu beeinflussen. Unsere Sehnsucht nach Anerkennung und Liebe treibt uns auch in die Unfreiheit vorgegebener Bilder, die wir glauben erfüllen zu müssen, um liebenswert zu sein. Sie hält uns in unserer westlichen Kultur in Äußerlichkeiten und schneller Käuflichkeit gefangen.

Als Kinder waren wir ohnmächtig der Zuwendung unserer Eltern ausgeliefert. Um der Ohnmacht zu entgehen versuchten wir Einfluss zu nehmen auf ihre Liebe, durch artiges Verhalten, durch Fleiß und tolle Leistungen. Werden wir älter, passen wir uns mit dieser Vorstellung nahtlos ein, in die offizielle Werteordnung der Gesellschaft: Wir versuchen uns liebenswert zu machen nach den anerkannten Regeln für Erfolg und gutes Aussehen. Wir adaptieren die herrschenden Glücksversprechungen, fügen uns in Rollenmuster, von denen wir uns Sicherheit und Wertschätzung erhoffen.

Wir orientieren uns an den Idealen unserer Gesellschaft, verinnerlichen sie und träumen von uns als anerkannte Mitglieder der Gemeinschaft. Oder wir rebellieren gegen ihre Werte und Gesetze, wenn wir nicht genug Aufmerksamkeit erhalten. Doch auch das vermeintliche Zerstören von Werten bestätigt diese letztlich in ihrer Wichtigkeit und zeigt die ursprüngliche Werteprägung des Revoluzers. Und genauso, wie in unserer Kindheit, bekämpfen wir damit nicht das eigentliche Problem. Unser Selbstwertgefühl hinkt immer nur hinter der äußeren Anerkennung her.

Wir beneiden schöne Menschen, weil wir glauben, sie bekämen im Übermaß das, was wir uns seit frühester Kindheit so sehnsüchtig wünschen: Liebe und Anerkennung, einfach so, ohne dafür etwas leisten zu müssen. Wir kämpfen gegen diese Sehnsüchte an, versuchen cool zu sein und unsere Gefühle zu beherrschen, wir versuchen, andere über ihre Sehnsüchte den unseren gefügig zu machen, weil wir Angst davor haben abhängig und hilflos zu werden – wie Kinder. Dabei können wir uns meist gar nicht richtig auf unsere Partner einlassen, selbst wenn sie wunderschön sind oder erfolgreich und man uns beneidet um ihren hohen „Marktwert“.

Wir reden von Liebe und meinen oft genug nur unsere Sehnsüchte, fordern vom anderen Wiedergutmachung für nicht erhaltene Zuwendung, versuchen ihn mit unserem Erfolg oder gutem Aussehen dahingehend zu bestechen. Doch unsere Kindersehnsucht kann nicht mit fremder Anerkennung gestillt werden, denn sie besteht aus einem Mangel an tiefer Bindung und einem fehlenden stabilen Selbstwertgefühl.

Es gilt also die in unserer Kindheit gelernten Muster und Regeln zu durchschauen, die Wunden in unserem Wertgefühl zu erkennen, um die eigentlichen Ursachen für unsere Probleme zu verstehen – und den Grund für unsere falschen (materiellen und äußerlichen) Vorstellungen vom Glück und von der Liebe. Wenn wir Einblick nehmen in unsere Prägungen und Werte, in unser so selbstverständlich geglaubtes Richtig und Falsch, Gut und Schlecht, wenn wir bereit sind uns unsere Fremdbestimmung bewusst zu machen, umzuwerten und umzulernen, dann erfahren wir den Funken der Freiheit und der Selbstbestimmung, zu dem wir Menschen doch fähig sind.

Identität ist eine Aufgabe. Sie zeigt sich in allem, was wir glauben und tun.

Katharina Ohana

www.katharinaohana.de

08 Jul 06:35

Developer Snapshots: Programmierer-News in ein, zwei Sätzen

Die Developer Snapshots diese Woche unter anderem mit dem Herbstcampus, der neuen Clojure User Group Bonn, der Programmiersprache ParaSail, den Python Tools for Visual Studio und Qt.

08 Jul 06:34

Playing with NHibernate – Inverse and Cascade mapping attributes

by mvazquez

Although I'm a big fan of Entity Framework, I have to admit that NHibernate provides a really flexible way of handling class inheritance and parent-child relationship. That said, I've noticed that these two important concepts are not very well explained in the documentation, which leads to a several discussions and debates in the community about the proper way of mapping your tables (and sometimes to explanations that state the opposite).

Consider the explanation of the inverse mapping (taken from the map collection):

Inverse: (optional – defaults to false) mark this collection as the "inverse" end of a bidirectional association.

If you think this explanation is incomplete, that makes two of us. There are some examples of the concept in the docs, but I couldn't find one that fully explains what this concept means and how you can use it together with the cascade (another mapping attribute). In the next few lines, I'm going to (try to) do this.

Scenario – One-to-many relationship

Let's define a simple scenario in which you have Products and Categories. And one Category can have many Products (i.e. a one-to-many relationship).
In this case, the Database diagram and the model classes should look similar to this:

Database diagram

Model classes

Basic mapping (default values)

Next, we are going to create mappings for these classes. Let's start with the default mapping values, just to see how NHibernate behaves as is:

Basic mapping

We are going to run a simple test case that creates a Category with 3 Products and saves everything in the DB. For this, we are setting the Product.Category property of each product before saving the data. Notice that we need to do everything ourselves: we have to associate the Category on each Product and we also have to save each entity in the session separately (and in a specific order, as we will be see later):

Note: you can find the solution with all the test cases here.

Basic mapping - Using Product.Category

As you can see in the image above, NHibernate generates the expected SQL statements (3 INSERTS). But there is an important caveat on this approach: you need to make sure that you're saving the entities in the right order. If you save the Products in the session before saving the Category, when committing the transaction NHibernate will behave as follows:

  • First, it will execute an INSERT statement for each Product, setting NULL in the CategoryId (which will only work if this column is nullable).
  • Then, it will execute an INSERT statement to save the Category.
  • Finally, it will execute an UPDATE statement for each Product to set the newly generated CategoryId.

Usually you should try to avoid doing things on your own, like saving the entities in the session in the right order or associating each Product with its Category individually (that's why we use an ORM in the first place, right?). To make things easier, NHibernate can handle this. In the next few lines we'll to remove some of our repetitive code by taking advantage of the Inverse and Cascade mapping attributes.

Setting Inverse to 'false' (default)

Let's analyze the way we are associating the Products with the Category. I know that some folks will prefer to add the 3 Products inside the Category.Products collection instead of setting the Category on each individual Product. What if I tell you that with the current mapping you can use both approaches? This is because we set the Inverse attribute in the Category.Products mapping to false (default value). So what Inverse does? It tells NHibernate that the Parent is responsible (or not) of saving the association to its childs. The inverse=false mapping means that when you save the Category you will also save the association of each Product that is inside the Category.Products collection. In constrast, setting this value to true basically means that "the Parent does not have the responsibility of saving the association".

Check the following code. Notice that instead of setting the Product.Category property we are now adding the Product to the Category.Products collection (and it works!):

Basic mapping - Using Category.Products

Although we've reduced the code a little bit, there are two problems with this approach (if we use the current mapping):

  1. To save the association, NHibernate will use an INSERT/UPDATE strategy for each Product (same as before), which won't work if we have a null constraint on the Product.CategoryId column.
  2. Inverse can be used only to save entity association info, not data. Hence, we still need to save each item individually. If we save only the Category (the Parent), NHibernate will throw the following TransientObjectException:

Basic mapping - Saving the Category only will throw an exception

A way to improve this approach is by setting the Cascade mapping attribute to a value different than 'none' (default). And that's what we are going to do in the next section.

Setting Cascade mapping attribute

mapping means that when you save the Category you will also save the association of each Product that is inside the Category.Products collection. In constrast, setting this value to true basically means that "the Parent does not have the responsibility of saving the association".
The Cascade mapping attribute helps NHibernate to decide which operations should be cascaded from the Parent object to the Child object. Collections mapped with a value different than 'none' will perform extra tasks in addition to saving the entity. For instance, you can set the collection with cascade=save-update, which means that when the object is saved/updated, NHibernate will check the associations and save/update any object that require it (for a complete explanation of all cascade values go here)

Let's update the mappings of the Category class by setting the cascade value to all:

Cascade mapping - Setting cascade mapping attribute

Now, we can safely remove the code that saves the products individually. By only saving the Category in the session will be enough since now we've instructed NHibernate to save the products "in cascade".

Cascade mapping - Setting cascade mapping attribute

Again, NHibernate will use the INSERT/UPDATE technique, which means that this approach won't work if the Product.CategoryId column is not-nullable.

Setting Inverse to 'true'

If you are facing the 'not-nullable' scenario, consider changing the Inverse property to true. Which means that the Category is no longer responsible to manage of the relationship. Then, update your code to associate the Products and the Categories using the Products.Category property (because the Product class is now the only owner of the association). Finally, you only need to save the Category in session (as before).

Cascade-Inverse mapping - Setting cascade and inverse mapping attributes

Summary

To sum up what we've explained:

  • The Inverse attribute tells NHibernate if the collection is responsible to manage the relationship. inverse=false means that it should update the relationship, while inverse=true means that 'it does not have to do anything'.
  • The Cascade attribute helps NHibernate to decide which operations should be cascaded from the parent object to the child object. For instance, cascade=save-update tells NHibernate that when the Parent is saved/updated, it also needs to needs to insert the Parent's childs.
  • Depending on the scenario you should decide which value to use on these two properties. For instance:
    • (one-to-many scenario) If your foreign-key allows nullable values, you can use a collection with inverse=false and a cascade value different than 'none'. When you save the Parent, NHibernate will take care of saving both childs and association.
    • (one-to-many scenario) If you have a not-nullable constraint in the DB, you can use a collection with inverse=true and a cascade value different than 'none'. In this case, you'll only need to associate the child with its parent in code before saving the parent.
27 Mar 09:33

MSSQL Shuffle Funktion zum anonymisieren von Daten

by Mario Priebe

Ich wollte einige Datensätze für die Testumgebung anonymisieren und heraus kam eine kleine Funktion, die ein zufälligen String generiert. Als Parameter wird der Funktion eine beliebige Zeichenfolge und die Angabe, wie lang der zufällige Wert sein soll, mitgegeben. Der erste Buchstabe im Resultat wird als Großbuchstabe zurückgegeben.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
CREATE VIEW Random
    AS SELECT RAND() AS RAND
GO
 
CREATE FUNCTION Shuffle(@string AS nvarchar(MAX), @LENGTH AS INT)
RETURNS VARCHAR(MAX)
BEGIN
    DECLARE @RESULT NVARCHAR(MAX)
    DECLARE @counter INT
 
    SET @RESULT = ''
    SET @counter = 0
 
    WHILE @counter < @LENGTH
    BEGIN
 
        SELECT @RESULT = @RESULT + SUBSTRING(@string, (SELECT CONVERT(INT, (RAND * LEN(@string) + 1)) FROM Random), 1)
        SET @counter = @counter + 1
    END
 
    SELECT @RESULT = UPPER(LEFT(@RESULT,1)) + SUBSTRING(@RESULT,2,LEN(@RESULT))
    RETURN @RESULT
END
GO

Aufzurufen wird das Ganze dann wie folgt:

1
2
UPDATE dbo.Persons
SET Lastname = dbo.Shuffle('abcdefghijklmnoprstuvwz', 8)

Alternativ könnte man anstelle der Zeichen, den alten Wert aus der Spalte und die Länge mitgeben,

1
2
UPDATE dbo.Persons
SET Lastname = dbo.Shuffle(Lastname, LEN(Lastname))

Viel Spaß beim entwickeln : )
Cool wäre jetzt noch, wenn man den String lesbar macht, hat einer eine Idee?

Ähnliche Beiträge

Zemanta

Dieser Beitrag stammt von Mario Priebe.

27 Mar 09:32

Tuple Eigenschaften lesbar gestalten?

by Mario Priebe

Die Verwendung von Tuple ist eine schnelle Lösung, wenn man beispielweise mehr als ein Parameter oder Rückgabewert benötigt. Ein Anwendungsfall wäre für mich, eine (semantische) Fehlermeldung anstelle von Exceptions. Also ein boolean und ein string als Rückgabewert “Tuple<bool, string>()”. Im string steht dann halt ein Grund drin, warum das Ganze schief gelaufen ist. So weit, so gut.

Das Resultat dabei ist leider nicht lesbar, denn ich bekomme den boolean im Property Item1 und den string in Item2 geliefert.

image

Aber okay, das mag so lange gut gehen, wenn man denn so etwas wie Konventionen für dieses “Pattern”definiert. Das Problem dabei ist hier, dass man sich hier schnell in tiefe Gewässer bewegt. Denn das kann auch ausarten, wenn man denn so etwas hier versucht: “Tuple<bool, string, Exception, bool, bool, decimal>()

image

Hier verliert man ganz schnell den Überblick.

Da hilft auch keine Dokumentation.

Hier käme mir die”glorreiche” Idee, die Tuple Properties lesbarer zu gestalten. Also baue ich mir eine Klasse, die von Tuple ableitet, in etwa so:

image

Nun stehen einem auch die Eigenschaften zur Verfügung.

image

Aber warum sollte ich dann von Tuple ableiten?

Macht kein Sinn. Bringt mir keinen Mehrwert. Ich kann das Ganze auch ohne.

image

Also warum dann Tuples einsetzen?

Was sagst du dazu? Wann setzt ihr Tuples ein? Wann machen Tuples Sinn? Mir fällt einfach kein Anwendungsfall ein.

Halt, vielleicht aber doch, möglicherweise für so etwas hier?

image

Nee, oder ;)

Nichts desto trotz, wer Tuples einsetzt, hat sicher auch seine Gründe dafür. Die mich natürlich brennend interessieren! Also nicht scheuen, 3-5 Minuten Zeit in die Hand nehmen und rein damit als Kommentar.

In diesem Sinne, viel Spaß beim entwickeln : )


Dieser Beitrag stammt von Mario Binder.

Ähnliche Beiträge