# Semantische Fehler



## MrHeez (16. Dez 2012)

Guten Abend,

die Suche nach einer gescheiten Definition von semantischen Fehlern in Java ist für mich nicht erfolgreich verlaufen. Einerseits habe ich gelesen, dass es logische Fehler sind, andererseits wurde dies aber auch teilweise von Leuten verneint. Jetzt bin ich mir nicht sicher, was nun richtig ist.

Hat da wer eine Antwort parat?


----------



## 3njoyeD (17. Dez 2012)

Eng neben der Semantik liegt die Syntax.
Syntax bedeutet Ordnung oder Reihenfolge.

Bei einer determinierten Schleife, also einer for-Schleife lautet die Syntax 
(int i = 0; i < array.length; i++)
In dieser Reihenfolge wird sie parametriert.
Die Semantik beschäftigt sich mit der Bedeutung.
Der Aufbau einer for Schleife hat also folgende Bedeutung:
for( <einmaliger befehl>; <bedingung>; <inkrementierung / update>)

Also kann man zur Definition sagen, dass semantische Fehler Fehlinterpretationen verursachen.
Sie können syntaktisch zwar richtig sein, ergeben aber nicht die gewünschte Funktion.

Ich hoffe, ich konnte damit helfen.


----------



## Ullenboom (17. Dez 2012)

Wie 3njoyeD im Grunde schon sage: Wenn der Compiler keinen Fehler schmeißt (Syntaktisch also alles korrekt ist), aber das Programm trotzdem nicht macht was es soll, so liegt ein semantischer Fehler vor.


----------



## Nuke77 (17. Dez 2012)

System.out.nuke77("Hallo Welt");

ist syntaktisch auch vollkommen korrekt, lässt sich trotzdem nicht kompilieren, und nu?


----------



## hüteüberhüte (17. Dez 2012)

Is ne Syntaxfehler, compiliert nicht.


----------



## Nuke77 (17. Dez 2012)

> compiliert nicht
Das hab ich ja schon gesagt...

> Is ne Syntaxfehler
Ist es eben nicht...


----------



## hüteüberhüte (17. Dez 2012)

ja klar, weil du das ja auch studiert hast. ^^


----------



## MrHeez (17. Dez 2012)

Vielen dank für eure zahlreichen Antworten.
Das Problem ist , dass wir in unserer derzeitigen Übung nach semantischen Fehlern in zwei Klassen suchen sollen. Das Programm berechnet die Fakultät einer eingegebenen Zahl durch JOptionPane. ABER das Programm berechnet ja eben wirklich die Fakultät also tut es ja das, was es auch soll. Deshalb frage ich mich wieso wir nach semantischen Fehlern suchen sollen? 

Ich möchte hier nicht den Code posten, da ich es gerne selbst lösen würde, deshalb versuche ich mal ein Beispiel so zu schreiben:
Also wir haben ein mal die Methode *private int berechne(int n)* in der die Funktion steht. Am Ende steht logischerweise unser Returnwert "erg". Also *return erg;*. Einige Zeilen über dieser Methode, haben wir die Methode *public void berechne() { this.berechne(n) }*, wobei "n" unser int is, welches wir eingegeben haben. Könnte es ein semantischer Fehler sein, dass es in der zweiten Methode nicht heißt *erg = this.berechne(n);*?? Wir haben in der private Methode zwar einen returnwert, der in der public zwar aufgerufen wird, aber nicht gespeichert wird.


----------



## Marco13 (17. Dez 2012)

hüteüberhüte hat gesagt.:


> Is ne Syntaxfehler, compiliert nicht.




```
class Out
{
    public void nuke77(String s) {}
}
class System
{
    public static Out out;

    public static void main(String args[])
    {
        System.out.nuke77("Hallo Welt");
    }

}
```

Die Grenzen sind fließend, sofern man nicht so präzise wird, dass der Aufwand für diese Präzision in keinem Verhältnis mehr zum Nutzen steht. 

MrHeez: IMHO hängt das davon ab, was im Kommentar steht. Wenn dort steht

```
/** Makes the processor busy */
public void berechne() { berechne(n); }
```
ist das OK. Wenn dort steht

```
/** Computes the 'erg'  */
public void berechne() { berechne(n); }
```
wäre das falsch, und müßte 

```
/** Computes the 'erg'  */
public void berechne() { erg = berechne(n); }
```
heißen. Aber alles ohne Gewähr. Es gibt schon komische Aufgabenstellungen.


----------



## MrHeez (17. Dez 2012)

*@Marco13:*

Solche Kommentare sind nicht vorhanden, nein. Uns wurde auch nicht richtig erklärt was semantische Fehler sind. 
Die ganze Übung geht über das Thema try/catch und throw. Aber es sind ja angeblich "syntaktische" Fehler , die Exceptions werfen. Wir sollen also diese syntaktischen mit try und catch behandeln, bei einem Fall eine Exception throwend UND noch nach semantischen Fehlern ausschau halten. Dennoch tut das Programm das, was es tun soll.


----------



## D4rkscr43m (17. Dez 2012)

MrHeez hat gesagt.:


> Aber es sind ja angeblich "syntaktische" Fehler , die Exceptions werfen.



nope,


```
System.out.println(1/0);
```

Syntaktisch korrekt, wirft aber trotzdem eine Exception.

Eben die semantischen Fehler sorgen für Ausnahmen.
Semantisch ist das, was über das angucken hinaus geht. (Zum Nachdenken verpflichtet)


----------



## Marco13 (17. Dez 2012)

Ja, ich vermute mal, dass nur gemeint ist, dass man schauen soll, ob das Programm "nicht das macht, was es soll (was auch immer das ist)"....


----------



## MrHeez (17. Dez 2012)

D4rkscr43m hat gesagt.:


> nope,
> 
> 
> ```
> ...



Gut da hast du natürlich Recht. In unserer Aufgabe (was du aber natürlich nicht wissen kannst) wird eine Exception nur geworfen, wenn man in das Eingabefeld durch JOptionPane was anderes als einen Int eingibt, da er ja danach nicht geparst werden kann. Ergo bekommen wir NUR die NumberFormatException und das ist kein semantischer Fehler, oder?


----------



## TryToHelp (17. Dez 2012)

3njoyeD hat gesagt.:


> ...
> Syntax bedeutet Ordnung oder Reihenfolge.
> ...
> Die Semantik beschäftigt sich mit der Bedeutung
> ....



Wie hier schon beschrieben, ist das also ein semantischer Fehler der dann auftritt und kein syntaktischer Fehler

Die Frage ist hier nach der Bedeutung der Eingabe.


----------



## D4rkscr43m (17. Dez 2012)

MrHeez hat gesagt.:


> Ergo bekommen wir NUR die NumberFormatException und das ist kein semantischer Fehler, oder?



Doch... aber deutlich interessanter sind die Fälle, bei denen keine Exception geworfen wird, die aber trotzdem nicht funktionieren.

Für negative Zahlen ist die Fakultät zum Beispiel nicht definiert, was passiert in dem Programm, wenn eine negative Zahl eingegeben wird?


----------



## TryToHelp (17. Dez 2012)

Hier nochmals eine Erklärung, die man mittels google suche findet und den Unterschied beschreibt zwischen syntax und semantik
denkspuren: Syntax und Semantik


----------



## Spacerat (17. Dez 2012)

Nach semantischen Fehlern kann man sich in Java evtl. auch einen Wolf suchen. Der #1 dieser Fehler (Zuweisung statt Vergleich in if-Abfragen) funktioniert in Java z.B. ja nur mit *boolean*s. Siehe hier.
Kurzum: Semantische Fehler sind syntaktisch korrekt und stören den Programmablauf (z.B. durch eine Exception) nicht. Sie führen nur zu falschen Ergebnissen und dadurch evtl. auch zu ungewollten Verzweigungen.
[EDIT]@Marco13: Das sind im Zweifelsfalle alles Ausnahme-, Syntax- oder Kompilerfehler.
Ausnahmefehler werfen 'ne Exception, Syntax- und Kompilerfehler lassen sich nicht kompilieren. Kompilerfehler sind z.B. Zugriffe (Verwendung) von nicht vorhandenen Klassen- bzw. Objektelementen ("System.out.foo()").
 Die "dummen Fehler" ("int thisVariableHasTheValueFive = 6") hab' ich komplett vergessen...
\/\/Was ist an dieser Abgrenzung schwer?\/\/[/EDIT]


----------



## Marco13 (17. Dez 2012)

@TryToHelp: Dort steht auch wieder, dass eine Abgrenzung schwierig ist. Ich finde, dass die Einteilung in Syntax und Semantik schlicht nicht ausreicht.

Syntaxfehler:
[c]String s = "hallo;[/c]

Was ist das? (ausgehend von java.lang.System  )
[c]System.out.foo("Hallo");[/c]

Und das?

```
String s = null;
int i = s.length();
```

Und das?

```
int thisVariableHasTheValueFive = 6;
```


----------



## D4rkscr43m (17. Dez 2012)

Marco13 hat gesagt.:


> @TryToHelp: Dort steht auch wieder, dass eine Abgrenzung schwierig ist. Ich finde, dass die Einteilung in Syntax und Semantik schlicht nicht ausreicht.
> 
> Syntaxfehler:
> [c]String s = "hallo;[/c]
> ...



Nach TryToHelp s Link sind zumindest die letzten 3 Beispiele semantische Fehler, da sie Kontextbezogen sind.


----------



## MrHeez (17. Dez 2012)

Die Aufgabe ist schon fertig bearbeitet, also kann ich euch den Code auch posten, damit ihr versteht was ich meine. Sorry für die Unannehmlichkeiten wollte es aber zuerst alles selbst lösen. Aber macht euch mal ein Bild und vllt. erkennt ihr ja den selben semantischen Fehler wie ich es tue:


```
import javax.swing.JOptionPane;

public class FakultInt {
	
	int n;
	int erg;
	
	public FakultInt(){
		eingabe();
		erg = 1;
	}
	
	public void eingabe() {
		
		do{
			String s = JOptionPane.showInputDialog("Geben Sie eine ganze Zahl ein:");
			n = Integer.parseInt(s);			
		} while(0>n || n>13);
		
		
	}
	
	public void berechne(){		
		this.berechne(n);
	}
		
	private int berechne(int n) {
		
		if(n == 0)
			erg = 1;
		else
			erg = n * berechne(n-1);
		return erg;
	}
	
	public void ausgabe(){
		System.out.println(n+"! = "+erg);
		
	}

}
```


----------



## Spacerat (17. Dez 2012)

Zeile 10: erg = 1, wozu? erg wird durch den Aufruf von "eingabe()" initialisiert.

Zur Auflösung hätte man "erg" mal kurz final machen können... die dadurch enstehenden Kompilerfehler hätten die verändernden Zugriffe markiert und so das Problem aufgezeigt. Daraus lernen wir nun auch noch, wofür das Schlüsselwort "final" alles gut sein kann, so nach dem Motto: "Wie, du hast 'nen semantischen Fehler und findest ihn nicht? Mach' doch was schwerwiegendes draus."


----------



## TryToHelp (17. Dez 2012)

Wo wird in eingabe bitte erg initialisiert?


----------



## Spacerat (17. Dez 2012)

TryToHelp hat gesagt.:


> Wo wird in eingabe bitte erg initialisiert?



Okay, nirgends... (irgendwie hab' ich angenommen, das "berechne()" direkt in bzw. gleich nach "eingabe()" aufgerufen wird)
Aber was solls, Zeile 10 bleibt trotzdem der Fehler. "erg" von "n" muss nicht unbedingt 1 sein. Ein Aufruf von "ausgabe()" würde ohne vorhergehendes "berechne()" einen falschen Wert liefern.
Daraus folgt, dass erg hier unbedingt als *final* deklariert werden muss, damit man blos nicht auf die Idee kommt, es uninitialisiert zu lassen.


----------



## Marco13 (17. Dez 2012)

D4rkscr43m hat gesagt.:


> Nach TryToHelp s Link sind zumindest die letzten 3 Beispiele semantische Fehler, da sie Kontextbezogen sind.



Ich finde den Begriff "Semantik" toll. Das kann man überall dazuschreiben. "Semantische Analyse".  "Semantischer Fehler". "Semantische Information". Und der Zugewinn an Semantik durch das davorschreiben von "Semantik" ist nahe 0. Wie auch immer: Die angedeuteten Fehler alle in einen Topf zu werfen wäre IMHO etwas zu unpräzise, aber man kann da natürlich beliebig weit gehen...


----------



## MrHeez (17. Dez 2012)

Spacerat hat gesagt.:


> Okay, nirgends... (irgendwie hab' ich angenommen, das "berechne()" direkt in bzw. gleich nach "eingabe()" aufgerufen wird)
> Aber was solls, Zeile 10 bleibt trotzdem der Fehler. "erg" von "n" muss nicht unbedingt 1 sein. Ein Aufruf von "ausgabe()" würde ohne vorhergehendes "berechne()" einen falschen Wert liefern.
> Daraus folgt, dass erg hier unbedingt als *final* deklariert werden muss, damit man blos nicht auf die Idee kommt, es uninitialisiert zu lassen.



Wir haben zwei Klassen. In unserer MainMethode wird erst das Objekt erstellt (d.h. bei der Initialisierung wird der Konstruktor genommen, eingabe(); geöffnet und erg = 1 eingesetzt). Und dann wird in der main die berechne Methode ausgeführt und dann die Ausgabe Methode.


----------



## Spacerat (17. Dez 2012)

MrHeez hat gesagt.:


> Wir haben zwei Klassen. In unserer MainMethode wird erst das Objekt erstellt (d.h. bei der Initialisierung wird der Konstruktor genommen, eingabe(); geöffnet und erg = 1 eingesetzt). Und dann wird in der main die berechne Methode ausgeführt und dann die Ausgabe Methode.


Das wäre der normale Verlauf. Man kann die Klasse FakultInt aber auch "mishandeln" in dem man nach der Initialisierung einer Instanz gleich "ausgabe()" aufruft. Die Ausgabe wäre dann unabhängig von der Eingabe 1 und das ist falsch (eigentlich genau das, was einen semantischen Fehler ausmacht).
@Marco13: Ich würde semantische Fehler im übrigen nicht so "veralbern", denn es sind die Fehler der übelsten Sorte. Sie sind nur sehr schwer zu lokalisieren, weil sich weder ein Kompiler drüber beschwert und nur wenn man Glück hat 'ne Exception fliegt (Im Falle des TO z.B. fliegt keine). Semantische Fehler sind nicht selten ein "Designfehler" wie im Falle des TO. Hier müsste z.B. jede Eingabe stets gleich ein Ergebnis liefern statt explizit angefordert zu werden.

```
import javax.swing.JOptionPane;

public class FakultIntMutable {

	int n;
	int erg;

	public FakultIntMutable() {
		n = eingabe();
	}

	public int eingabe() {
		int n;
		do {
			String s = JOptionPane
					.showInputDialog("Geben Sie eine ganze Zahl ein:");
			n = Integer.parseInt(s);
			erg = berechne(n);
		} while (0 > n || n > 13);
		return n;
	}

/*	public void berechne() {
		this.berechne(n);
	}*/

	private int berechne(int n) {

		if (n == 0)
			return 1;
		return n * berechne(n - 1);
	}

	@Override
	public String toString() {
		return n + "! =" + erg;
	}

	public void ausgabe() {
		System.out.println(toString());
	}

	public static void main(String[] args) {
		FakultIntMutable fi = new FakultIntMutable();
		System.out.println(fi);
		for(int n = 0; n < 10; n++) {
			fi.eingabe();
			System.out.println(fi);
		}
	}
}

class FakultIntImutable {

	final int n;
	final int erg;
	final String out;

	public FakultIntImutable() {
		n = eingabe();
		erg = berechne(n);
		out = n + "! = " + erg;
	}

	public int eingabe() {
		int n;
		do {
			String s = JOptionPane
					.showInputDialog("Geben Sie eine ganze Zahl ein:");
			n = Integer.parseInt(s);
		} while (0 > n || n > 13);
		return n;
	}

/*	public void berechne() {
		this.berechne(n);
	}*/

	private int berechne(int n) {

		if (n == 0)
			return 1;
		return n * berechne(n - 1);
	}

	@Override
	public String toString() {
		return out;
	}

	public void ausgabe() {
		System.out.println(out);
	}

	public static void main(String[] args) {
		System.out.println(new FakultIntImutable());
	}
}
```


----------



## MrHeez (17. Dez 2012)

Naja, aber als Java Anfänger sich an solchen Beispielen zu probieren? Wäre da nicht so schnell drauf gekommen und in der Zeit hätte man auch viele andere Sachen machen und lernen können. 

Vielen Dank aber an alle!


----------



## Marco13 (17. Dez 2012)

@Spacerat: Ich habe nicht die Fehler veralbert, sondern bestenfalls den Begriff "Semantik" (aber vielleicht sogar eher seine inflationär-pseudointellektuelle Verwendung: Wenn man es pragmatisch mit "Bedeutung" übersetzt, merkt man, dass es fast nichts gibt, was keine "Semantik" hat ... selbst weißes Rauschen hat Semantik - nämlich im Zweifelsfall die, keine Struktur zu haben oder eben weißes Rauschen zu sein). 
Wie auch immer. 
Der wichtigere Punkt war, dass die 4 Fehler, die ich anskizziert hatte, IMHO in 4 vollkommen verschiedene Kategorien fallen: Der erste war syntaktisch. Der zweite wird noch vom Compiler erkannt. Der dritte wird von der JVM erkannt und durch eine Exception quittiert. Der letzte kann nur von einem Menschen mit Weltwissen erkannt werden, falls es überhaupt einer war. Und die letzten 3 in eine Kategorie zu packen (nach dem Motto Semantisch = !Syntaktisch) schwächt den Begriff noch einmal mehr...


----------



## Spacerat (17. Dez 2012)

Marco13 hat gesagt.:


> Und die letzten 3 in eine Kategorie zu packen (nach dem Motto Semantisch = !Syntaktisch) schwächt den Begriff noch einmal mehr...


Dann hab' ich wohl etwas falsch verstanden oder du hast Semantik (in der Informationstheorie) nicht kapiert. Wie gesagt, deine letzten drei Beispiele sind keine semantischen Fehler. Die ersten beiden fallen sofort auf und der letzte ist äh... wer macht denn so was eigentlich? Stellen wir uns einfach mal vor, dass die Variable im Toplevel eh' EIA, EIB oder ähnlich heisst. Aber ein (semantischer) Fehler wie jener vom TO hat's im Zweifelsfalle schon in sich. Versuch' einen solchen mal in einem grösseren Projekt zu finden, er produziert ja keine Fehlermeldungen, man sieht bzw. hört nur, dass da offensichtlich was falsch läuft. Ich z.B. stelle mir grad' die Frage, warum sich bei mir einige Protracker-Module so besch... anhören. Da läuft halt irgend was schief und man sucht sich 'nen Wolf. Es gibt nichts was diesen Begriff schwächt und nichts was dich vor solchen Fehlern schützt.


----------



## Nuke77 (17. Dez 2012)

Spacerat hat gesagt.:


> Syntax- und Kompilerfehler lassen sich nicht kompilieren.



Ach, "Kompilerfehler" sind Fehler die sich nicht kompilieren lassen, hmm, klasse, du bringst echt viel in die Diskussion ein.

Ich weiß leider nicht warum so viele die Begriffe nicht richtig verwenden können. Jeder der einen Deut von Wissen vom Compilerbau hat weiß in welcher Phase welche Fehler auftreten. Der Lehrer hier meint mit semantischen Fehlern allerdings offenbar leider Logikfehler (aka "Bugs") die er in den Code eingebaut hat.


----------



## Spacerat (17. Dez 2012)

Nuke77 hat gesagt.:


> Ach, "Kompilerfehler" sind Fehler die sich nicht kompilieren lassen, hmm, klasse, du bringst echt viel in die Diskussion ein.
> 
> Ich weiß leider nicht warum so viele die Begriffe nicht richtig verwenden können. Jeder der einen Deut von Wissen vom Compilerbau hat weiß in welcher Phase welche Fehler auftreten. Der Lehrer hier meint mit semantischen Fehlern allerdings offenbar leider Logikfehler (aka "Bugs") die er in den Code eingebaut hat.


Weis grad' nicht, wie ich das deuten soll... Wann bitte treten denn Kompilerfehler auf, wenn nicht beim kompilieren (z.B. wenn der Kompiler merkt, wenn in einer Klasse ein verwendeter Member oder eine verwendete Methode nicht definiert ist)? Vernünftige Kompiler brechen den Kompilevorgang dann halt ab. Habe ich (im Gegensatz zu dir) einen Begriff falsch verwendet? Semantische Fehler fallen zwar auch in die Kategorie Bug, Bugs aber können noch viel mehr sein, was nicht unbedingt etwas mit Semantik zu tun hat.


----------



## Marco13 (18. Dez 2012)

@Spacerat: Ja, ich habe wohl "Semantik nicht kapiert", wenn man von dem Baum ausgeht, dessen Stamm durch Semantik ? Wikipedia gegeben ist. Eingeschränkt wurde es nicht, bis du jetzt die Informationstheorie erwähnt hast, die ich aber mit den Fehlern, um die es hier vermutlich geht, kaum in Verbindung bringen würde. (Ehrlich gesagt will ich aber gar nicht über den Begriff Semantik an sich philosophieren, das machen andere schon genug).

In dem Edit (über meiner Fehlerauflistung) hattest zu einen der Fehler zumindest noch als "Ausnahmefehler" klassifiziert, aber was genau der Aufgabensteller wollte, darüber kann man wohl ohnehin nur spekulieren.


----------



## Spacerat (18. Dez 2012)

Was ist denn das bitte für ein Wiki? Wieso unterscheiden die dort noch mal zwischen Semantik in der Informationstheorie und Semantik in der Informatik? Sind das Philosophen bahnhof: nee, dann hätten's wohl kaum auch noch Semantik in der Sprachphilosophie erwähnt :lol oder Informatiker? Na was soll's, nach den Erklärungen dort, hätte ich von Semantik auch keine Ahnung, also ist's in vielerlei Hinsicht kein Wunder, wenn ständig solche Fragen kommen oder diese Dinger schlicht als Bug bezeichnet werden.


Marco13 hat gesagt.:


> ...aber was genau der Aufgabensteller wollte, darüber kann man wohl ohnehin nur spekulieren.


Na eine genaue Definition von semantischen Fehlern, nehm ich mal an (Die Frage war ja deutlich genug). Aber um eben eine solche Definition zu finden, müssen Fehler im Allgemeinen erst mal spezifiziert (klassifiziert) werden. Genau das habe ich im Prinzip mit deinen Beispielen gemacht.[WR]Semantische Fehler sind kompilierbar und stören nur den Daten-bzw. Informationsfluss zur Laufzeit, jedoch nicht den eigentlichen Programmablauf.[/WR]

Evtl. hilft beim Verständnis auch nur einschlägige Erfahrung mit einem semantischen Fehler: Selber einen produzieren, ohne zu wissen wann und wo (das ist einfacher als man denkt). Evtl. macht er sich irgendwann sogar bemerkbar, je früher desto besser, ansonsten viel Glück beim Beseitigen .
BTW.: Wenn man z.B. ein Programm dadurch zum Absturz bringen kann, indem man ungültige Parameter an eine Methode übergibt, ist das ebenfalls ein Bug, jedoch kein semantischer Fehler. Wenn man z.B. ein Pluginsystem dadurch zum Absturz bringen kann, indem man in der "init()"-Runde eine Ausnahme wirft (in Java eine RTE), ist das ebenfalls ein Bug, jedoch kein semantischer Fehler. Wenn man versucht semantische Fehler durch das Fangen aller möglichen Ausnahmen ("catch(Throwable t) {}") in diversen Programmabschnitten auszumerzen ist das Aberglaube (bzw. ein "dummer" Fehler).


----------



## Marco13 (18. Dez 2012)

Das ist schlicht ein Wiki, wo Philosophen und Informatiker darüber philosophieren (oder informatiken) was die richtige Definition von "Semantik" ist (BTW: Siehe auch den MouseOver-Text von xkcd: Extended Mind ). Und ich hatte ja von einem "Stamm" geredet: Der Hauptartikel ist ja eigentlich nur eine Auflistung, WAS der Begriff WO bedeutet (oder nicht mal das, sondern vielleicht nur, wie er interpretiert wird (und vielleicht nicht mal das, sondern nur, was der Artikelschreiber für die gängigste Interpretation hielt)). 

Deiner Definition nach ist ein "semantischer Fehler" (="Logikfehler"?) eben das, was kein Syntaxfehler ist, und nicht das, was man als "Laufzeitfehler" (="Ausnahmefhler"?) bezeichnen könnte, sondern eben die Fehler, die besagtes Wissen über das Ziel des Programms voraussetzen. Trotzdem sind diese Begriffe in Einzelfällen schwer voneinander abzugrenzen...


----------



## Spacerat (18. Dez 2012)

Marco13 hat gesagt.:


> Deiner Definition nach ist ein "semantischer Fehler" (="Logikfehler"?) eben das, was kein Syntaxfehler ist, und nicht das, was man als "Laufzeitfehler" (="Ausnahmefhler"?) bezeichnen könnte, sondern eben die Fehler, die besagtes Wissen über das Ziel des Programms voraussetzen. Trotzdem sind diese Begriffe in Einzelfällen schwer voneinander abzugrenzen...


Nicht blos Logik sondern z.B. auch Timing oder DA-AD-Wandlungen (von Fliesskomma zu Integer und umgekehrt, wenn man so will), kurz, alles was mit dem Datenfluss zusammenhängt oder alles, was den Programmablauf nicht durch Abbruch oder Interaktion stört, jedoch merklich etwas falsch läuft (z.B. mein Sequencer-Datentyp; läuft zwar durch aber klingt bescheiden).
Jetzt weis ich nicht, welche Begriffe du da noch abgrenzen willst. Das Programm läuft, also fallen Syntax- und Kompilerfehler schon mal aus. Ausnahmefehler treten auch nicht auf und im Log findet sich auch nichts. Aber da merklich etwas schief läuft, weis man, dass das Programm mindestens einen Fehler (nämlich einen semantischen) hat. Die Mühe jetzt noch abzugrenzen welche Art von semantischen Fehler man hat (sofern das überhaupt geht), kann man sich sparen, denn man hat andere Probleme und zwar mitunter auch solche, wo evtl. nicht mal ein Blick in eine Dokumentation hilft, denn dort findet man nur das, was dem jeweiligen Programmabschnitt angedacht wurde. Genau deswegen sind Semantikfehler, Fehler der übelsten Art und werden meines Wissens nur noch durch die "sporadischen" (zeitweilig auftretende) getoppt.


----------



## Marco13 (18. Dez 2012)

Weiter abgrenzen (im Sinne einer feineren Klassifizierung) muss man da ja nicht unbedingt - auch wenn z.B. die gesonderte Betrachtung von Timing-Fehlern (Race Conditions, Deadlocks) vielleicht gerechtfertigt wäre. Ich meinte die Abgrenzung der Fehler untereinander. Wenn man eine boolean-Variable nicht volatile macht, und deswegen ein Thread die Änderung der Variablen nicht mitbekommt, was ist das dann? (Und was ist eigentlich eine 'rethorische Frage'?  ).

Wenn man es drauf anlegen würde, könnte man noch versuchen, eine begriffliche Unterscheidung zu finden, zwischen

```
int compute(int array[])
{
    int result = 1;
    for (int i=0; i<array.length; i++) result += array[i];
}
```
(kein Fehler)
und 

```
/** Computes the product of the array elements */
int compute(int array[])
{
    int result = 1;
    for (int i=0; i<array.length; i++) result += array[i];
}
```
(komplett falsch), aber im Zweifelsfall nenne ich (so wie Kunden es wohl meistens auch tun) jeden Fehler einfach "Bug"


----------



## Nuke77 (18. Dez 2012)

Spacerat hat gesagt.:


> Wann bitte treten denn Kompilerfehler auf, wenn nicht beim kompilieren


Natürlich treten "Kompilerfehler" beim kompilieren auf, das war der Punkt den ich gemacht hab: der Begriff ist sinnlos und nichtssagend, trotzdem verwendest du ihn weiter. Sind Syntaxfehler etwa keine Kompilerfehler oder treten Syntaxfehler nicht beim kompilieren auf?



> Vernünftige Kompiler brechen den Kompilevorgang dann halt ab.


Dann sind die meisten Compiler anscheinend unvernünftig, ich hab jedenfalls noch keinen Hochsprachen-Compiler gesehen der beim ersten Semantischen Fehler (!) abbricht.


----------



## Ark (18. Dez 2012)

[OT]





Marco13 hat gesagt.:


> BTW: Siehe auch den MouseOver-Text von xkcd: Extended Mind


Da könnte was dran sein, auch in der deutschen Wikipedia. Hab' mal auf "Zufälliger Artikel" geklickt, landete so zuerst bei "San Benedetto Po" und nur einige wenige Artikel später tatsächlich bei "Philosophie". :reflect:[/OT]

Ark


----------



## Marco13 (18. Dez 2012)

[OT]


Ark hat gesagt.:


> Da könnte was dran sein, auch in der deutschen Wikipedia. Hab' mal auf "Zufälliger Artikel" geklickt, landete so zuerst bei "San Benedetto Po" und nur einige wenige Artikel später tatsächlich bei "Philosophie". :reflect:



Ja, ich hatte es auch bei mehreren ausprobiert. Speziell beim Englischen scheint es aber zuverlässiger/schneller zu funktionieren (und natürlich muss man Endlosschleifen auflösen). Da wurde auch ein "Spiel" draus gemacht: xkcd &bull; View topic - Wikipedia: Philosophy  

[/OT]


----------



## Spacerat (18. Dez 2012)

Marco13 hat gesagt.:


> ...Timing-Fehlern (Race Conditions, Deadlocks)...


Hätte ich vllt. dazuschreiben sollen, aber genau die meinte ich nicht, zumindest nicht letztere. Ich meinte solche, wenn z.B. ein Frequenzgenerator Aufgrund eines Rundungsfehlers 49,789Hz statt 50Hz liefert, wodurch man auch für die Periodendauer falsche Werte erhält, welche man eigentlich aufsummieren wollte.
Dein letztes Beispiel ist die Art semantischer Fehler, die man beim Vergleichen der Dokumentation mit dem eigentlichen Code weg bekommt. Versuch das mal bei solchen, wo die Doku mit dem Code übereinstimmt, sich der Fehler aber wegen solchen Ungenauigkeiten einschleicht.



Nuke77 hat gesagt.:


> Dann sind die meisten Compiler anscheinend unvernünftig, ich hab jedenfalls noch keinen Hochsprachen-Compiler gesehen der beim ersten Semantischen Fehler (!) abbricht.


Ich auch nicht, denn weder Kompiler noch Preprozessor erkennen semantische Fehler, nicht mal das Programm selber, wenn es läuft. Ich hab' ja auch die Kompilerfehler gemeint. Und nein, Syntaxfehler sind keine Kompilerfehler. Ein Kompiler fängt gar nicht erst an zu kompilieren, wenn die Syntax nicht stimmt.


----------



## Nuke77 (18. Dez 2012)

Spacerat hat gesagt.:


> Ich auch nicht, denn weder Kompiler noch Preprozessor erkennen semantische Fehler, nicht mal das Programm selber, wenn es läuft. Ich hab' ja auch die Kompilerfehler gemeint. Und nein, Syntaxfehler sind keine Kompilerfehler. Ein Kompiler fängt gar nicht erst an zu kompilieren, wenn die Syntax nicht stimmt.



Ok hier bin ich raus aus der Diskussion mit dir. Es täte dir gut dir vielleicht mindestens _Grundlagen_ zum Thema Compilerbau und/oder formale Sprachen allgemein anzueignen bevor du in so eine Diskussion einsteigst, ansonsten hat so ein Thread wenig Sinn.

Der Tipp gilt übrigens für alle Threads auch zu anderen Themen, denn wenn ich mich richtig erinnere bist du der selbe Typ der neulich noch behauptet hat in PHP würde man nicht objektorientiert programmieren. Nix für ungut...


----------



## Spacerat (18. Dez 2012)

Nuke77 hat gesagt.:


> Ok hier bin ich raus aus der Diskussion mit dir. Es täte dir gut dir vielleicht mindestens _Grundlagen_ zum Thema Compilerbau und/oder formale Sprachen allgemein anzueignen bevor du in so eine Diskussion einsteigst, ansonsten hat so ein Thread wenig Sinn.
> 
> Der Tipp gilt übrigens für alle Threads auch zu anderen Themen, denn wenn ich mich richtig erinnere bist du der selbe Typ der neulich noch behauptet hat in PHP würde man nicht objektorientiert programmieren. Nix für ungut...


Dem stimme ich zu und stehe voll dahinter, denn wer was anderes behauptet kennt anscheinend gerade mal Grundlagen, denke ich. Aber was soll's, da kommst du auch noch hinter.


----------



## Olli_M (18. Dez 2012)

Hmm, ich hatte mal folgenden Fehler: ein NumberFormat Objekt in 2 verschiedenen Threads verwendet,
was zur Folge hatte, dass die formatierten Werte (in völlig unreproduzierbarer Weise) sporadisch einfach falsch waren. Einfach weil NumberFormat nicht threadsicher ist. 
(Abhilfe: jedem Thread sein eigenes NumberFormat Objekt geben)

Kompiliert, stört den Programmablauf nicht, ergibt "nur" falsche Werte (und ärgert den Entwickler durch stunden- oder besser gesagt tagelanges Suchen nach der Fehlerursache).

Dagegen sind Syntaxfehler oder Runtime Exceptions meistens viel schneller zu finden/lösen.

Olli


----------

