Grottiger C-Code

Ich denke bei der ganzen Diskussion sollte man mal versuchen einige Dinge sauber von einander trennen:

Sicherheitskritisch hat hier eine Doppelbedeutung:
-im Sinne von safety, d.h. Umwelteinflüsse, Ausfallsicherheit, Echtzeit (bspw. Software für Bremssysteme in einem ICE)
-im Sinne von security, d.h. Angriffe (von außen) durch Dritte

Dann muss man verschiedene Fehlertypen unterscheiden:
-Failure
-Anomaly
-Error

Und damit obige genannte Fehlertypen nicht auftauchen:
-Debugging
-Testing

Und abseits davon dann bzgl. Quellcode:
-readability
-integrity
-meaningful comments
-...

Und abseits des Quellcodes:
-project documentation
-proper software management (d.h. u.a. das eben auch für die Einhaltung der Anforderungen gesorgt wird, sinnvolle Entwicklungs- und Releasezyklen, Update- und Patch management usw)

Zu sagen was nun 'guter' Code ist, ist schwierig. Der Code kann noch so gut dokumentiert und kommentiert sein aber sicherheitstechnisch (in beiden Bedeutungen) eine Katastrophe.
Wenn Werkstudenten Code für solche Bereiche schreiben ist das die Schuld der Unternehmen die Dank Kostendruck und Ausschreibungsregelwerk die Studenten für solche Aufgaben abstellen, statt dafuer einen qualifizierten Programmierer zu bezahlen.
 
Security spielt hier überhaupt keine Rolle, es geht hier rein um Zuverlässigkeit. Mit Deiner Unterscheidung von Fehlertypen kann ich nichts anfangen. Kannst Du erklären worin die sich unterscheiden sollen?

Ein Echtzeitsystem (und darum geht es bei µCs ja eigentlich immer) muss stets in einem definierten Zustand sein.

Auf die Ebene Projektmanagement, Dokumentation und Releasezyklen muss man bei diesem Müll echt nicht gehen, damit kommt man schierer Inkompetenz schlicht nicht bei.
 
Das sind Begriffe aus dem Software Testing. Zusammengefasst in etwa:

Failure (Fehler)
Inability to perform its required functions (non-compliance to specification)

Anomaly (Mangel)
Deviation from qualified expectations

Error (Fehlerwirkung)
Visible effect of failure

Dabei wird für gewöhnlich auf IEEE 1044 verwiesen (bspw. http://www.baskent.edu.tr/~zaktas/courses/Bil573/IEEE_Standards/1044_2009.pdf ), wobei es teilweise unterschiedliche Definitionen dazu gibt.

Dabei werden dann oft verschiedene Zustände (Fehlhandlung, Fehlerzustand und Fehlerwirkung) unterschieden.

Entsprechend wird dann das Testing (systematisches finden von 'errors') und Debugging (finden und beheben von faults/bugs) unterschieden. Idealerweise sollten das dann also auch zwei verschiedene Personen machen.

Wenn man jetzt noch dank Projektmanagement Review-Phasen und co hat kann man zumindestens insgesamt die Code-Qualität verbessern. Fehlerfrei wird sie halt nie sein, aber das geht bei großen Projekten eben auch schwierig ...

Klar, wenn man davon ausgeht das alle total inkompetent sind, kann man es direkt sein lassen :-)

EDIT: In einer perfekten Welt mit endlos viel Zeit wäre durch das Projektmanagement auch die Schulung der Projektbeteiligten integriert, um z.B. gerade bei Code-Doku alle auf ein Niveau zu bringen ... ach ja ... schöne perfekte Welt :-)
 
Zuletzt bearbeitet:
k_e_x schrieb:
Failure (Fehler)
Inability to perform its required functions (non-compliance to specification)

Anomaly (Mangel)
Deviation from qualified expectations
Zum Vergrößern anklicken....
Ist für mich das gleiche. Die Erwartungen stehen in der Spezifikation. Sonst ist die Spezifikation kaputt.

k_e_x schrieb:
Error (Fehlerwirkung)
Visible effect of failure
Zum Vergrößern anklicken....
Das ist ein Attribut, keine eigene Klasse.
 
Das ist sicher ein Thema mit langer Diskussionsgeschichte wie man die Begriffe definiert. Wenn du die für dich anders betrachtest werde ich da nicht versuchen dagegen zu argumentieren ... siehe entsprechende Bücher / Standards zu dem Thema ... da sind dann auch sinnvolle und einleuchtende Beispiele drin.
 
Die Diskussion ist ja ganz nett, aber kann mir mal bitte Irgendjemand stichpunktartig (als Aufzaehlung) definieren, was denn genau "guter" bzw. "schlechter" C code denn sei?

Waehre (als Startingpoint) fuer Anfaenger hilfreich, um Fehler zu vermeiden ueber die sich andere Mitmenschen moeglicherweise echauffieren.

Als Anfnger tappt man oftmals im Dunkeln und steht dann wie ein Ochs' vorm Berg, was unfreiwillig Fehler impliziert (aufgrund Unwissenheit, weil man als Anfaenger nicht die Moeglichkeit hat, das "Richtige" Manual zu finden, da man oftmals nicht wissen kann wo man denn suchen soll, wenn Bereitschaft zu Lesen und Lernen gegeben ist), die dann wiederrum unfreiwillig komisch wirken (oftmals fatale Konsequenzen nach sich zoegen). :)

Just my 2 ct.
 
das.chaos: Schon deine Vorstellung es wäre mit einer Aufzählung in Listenform zu erledigen ist belustigend. Was hilft ist guten Code lesen und etwas verändern sowie sich endlich mal das ANSI C Buch besorgen.
 
@ crest: danke :)

Das besagte Buch habe ich, bzw. auch Expert C Programming mit interesse gelesen. Es ist logisch (man verzeihe mir, wenn mein vorangegangenes Posting als Provokation wahrgenommen wurde), dasz eine "Aufzaehlung" nicht wirklich ein derartig komplexes Themengebiet erklaerbar erscheinen laesst.

Selbstverstaendlich studiere ich Code, bspw. der in /usr/src/sys/... vorzufindene. Mir geht es eher um Detailfragen, bspw. wann welche Konvention oder Verfahrensweisen Gueltigkeit tragen und wann denn nicht. Mir ging es eher um eine Auflistung von Konventionen oder industrienormen (i.e. POSIX ist mir bekannt), wo ich dann selbst recherchieren kann.

Ich betrachte mich als (blutiger) Anfaenger (mit etwas Groeszenwahn, der aber Lernwillig ist). Ich kann definitiv nicht beurteilen inwiefern Code qualitativ zu bewerten sei. Bitte mich jetzt nicht fuer das folgende Beispiel Steinigen! :)

Beim Konsultieren spezifischer Informationsqellen bin ich oftmals verwirrt: die eine sagt mir dasz ich keine goto's verwenden darf...
Code: 
struct protoent {
    hook_p hook; 
    uint16_t type;
};

/* 
 * ... hier steht ne menge zusammengefrickelter trash, 
 * den ich jetzt ausgeblendet habe ...
 */
 
static int
ng_etype_split_rcvdata(hook_p hook, item_p item)
{ 
	int err = 0;

	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
	const struct protoent *src = NG_HOOK_PRIVATE(hook);
	
	if (!src) {
		err = EINVAL;
		if (item)
			NG_FREE_ITEM(item);	
	} else { 	
                struct mbuf *m;
	
		NGI_GET_M(item, m);
		if (m->m_pkthdr.len < ETHER_HDR_LEN) { 
			err = EINVAL;
			NG_FREE_M(m);
			NG_FREE_ITEM(item);
		} else {
			/* 
			 * If data field of message primitive  
			 * is contiguous. 
			 */
			if (m->m_len < ETHER_HDR_LEN) {
				m = m_pullup(m, ETHER_HDR_LEN);
				if (!m) {
					err = ENOBUFS;
					NG_FREE_ITEM(item);
				} 
			} else {
				struct protoent *dst = NULL;
		                struct ether_header *eh;

                                switch (src->type) {
				case ETHERTYPE_ARP:		
				case ETHERTYPE_IP:
				case ETHERTYPE_PPPOE:	
				case ETHERTYPE_PPPOEDISC:		
				case ETHERTYPE_REVARP:
					if (sc->sc_downstream.hook)
						NG_FWD_NEW_DATA(err, item, sc->sc_downstream.hook, m);
					else {
						err = EINVAL;
						NG_FREE_M(m);
						NG_FREE_ITEM(item);
					}
					break;
				default: /* If frame comes from downstream... */
 					eh = mtod(m, struct ether_header *);
 			
					switch (ntohs(eh->ether_type)) {
					case ETHERTYPE_ARP:		
						dst = &sc->sc_arp;
						break;
					case ETHERTYPE_IP:
						dst = &sc->sc_ip;
						break;
					case ETHERTYPE_PPPOE:	
						dst = &sc->sc_pppoe;
						break;
					case ETHERTYPE_PPPOEDISC:		
						dst = &sc->sc_pppoedisc;
						break;
					case ETHERTYPE_REVARP:
						dst = &sc->sc_rarp;
						break;
					default:
						err = EINVAL;
					}

					/*
					 * ... every mbuf chain wich holds data not in a 
					 * cluster may be transformed for further processing, 
                                         * but single message primitives may passed and 
                                         * won't be touched.
		 			 */
					if (dst) {
						if (dst->hook) {
							if (m->m_next) { 
                                                        	int len = m->m_pkthdr.len;
								char buf[len];
								struct mbuf *n;	
					
								MGET(n, M_NOWAIT, MT_DATA);
								if (!n) { 
									err = ENOBUFS;	
									NG_FREE_M(m);
									NG_FREE_ITEM(item);
								} else {
									MCLGET(n, M_NOWAIT);
									if (!(n->m_flags & M_EXT)) {
										err = ENOBUFS; 
										m_freem(n);
										NG_FREE_M(m);
										NG_FREE_ITEM(item);
									} else {
        
                                                                        /* frickel, frickel frickel :) */
										m_move_pkthdr(n, m);
										m_copydata(m, 0, len, buf);
				                                                m_freem(m);

										if (!m_append(n, len, buf)) {
											err = ENOBUFS; 
											m_freem(n);
											NG_FREE_M(m);
											NG_FREE_ITEM(item);
										} else {			
											NG_FWD_NEW_DATA(err, item, dst->hook, n);
									}
								}
							} else 
								NG_FWD_NEW_DATA(err, item, dst->hook, m);
						} else {
							NG_FREE_M(m);
							NG_FREE_ITEM(item);
						} 
					} else {
							NG_FREE_M(m);
							NG_FREE_ITEM(item);
					}	
				} 
			}
		}	
	}
	
	return(err);
}
und die Andere meint alles o.k. das passt schon irgendwie...
Code: 
static int
ng_etype_split_rcvdata(hook_p hook, item_p item)
{ 
	int err = 0;
	struct mbuf *m;
	const sc_p sc = NG_NODE_PRIVATE(NG_HOOK_NODE(hook));
	const struct protoent *src = NG_HOOK_PRIVATE(hook);
	
	if (!src) {
		err = EINVAL;
		if (item)
			NG_FREE_ITEM(item);
	} else { 	
                struct protoent *dst;
                struct ether_header *eh;
                uint16_t type;  
               
                NGI_GET_M(item, m);
		if (m->m_pkthdr.len < ETHER_HDR_LEN) { 
			err = EINVAL;
			goto bad;
		}
	
		/* 
		 * If data field of message primitive  
		 * is contiguous. 
		 */
		if (m->m_len < ETHER_HDR_LEN) {
			m = m_pullup(m, ETHER_HDR_LEN);
			if (!m) {
				err = ENOBUFS;
				goto bad;
			} 
		}
	
                eh = mtod(m, struct ether_header *);
                type = ntohs(eh->ether_type);

		switch (src->type) {
		case ETHERTYPE_ARP:		
		case ETHERTYPE_IP:
		case ETHERTYPE_PPPOE:	
		case ETHERTYPE_PPPOEDISC:		
		case ETHERTYPE_REVARP:
                        if (src->type == type && sc->sc_downstream.hook)
                        	NG_FWD_NEW_DATA(err, item, sc->sc_downstream.hook, m);
			else {
				err = EINVAL;
				goto bad;
			}

                        break;
		case ORPHAN:
                        if (sc->sc_downstream.hook)
				NG_FWD_NEW_DATA(err, item, sc->sc_downstream.hook, m);
			else {
				err = EINVAL;
				goto bad;
			}
			
			break;     
                default: /* If frame comes from downstream... */
			switch (type) {
			case ETHERTYPE_ARP:		
				dst = &sc->sc_arp;
				break;
			case ETHERTYPE_IP:
				dst = &sc->sc_ip;
				break;
			case ETHERTYPE_PPPOE:	
				dst = &sc->sc_pppoe;
				break;
			case ETHERTYPE_PPPOEDISC:		
				dst = &sc->sc_pppoedisc;
				break;
			case ETHERTYPE_REVARP:
				dst = &sc->sc_rarp;
				break;
			default:
				dst = &sc->sc_orphan;
			}

		/*
		 * ... every mbuf chain wich not holds data in a 
	         * cluster may be transformed for further processing,
                 * but single message primitives may passed and won't
		 * touched or passed throught orphan hook, if possible.
		 */
			if (dst->hook) {
				if (m->m_next) { 
					int len = m->m_pkthdr.len;
                                        char buf[len];
                                        struct mbuf *n;
					
                                        MGET(n, M_NOWAIT, MT_DATA);
					if (!n) {
						err = ENOBUFS;	
						goto bad;
					}
				
					MCLGET(n, M_NOWAIT);
					if (!(n->m_flags & M_EXT)) {
						m_freem(n);
						err = ENOBUFS; 
						goto bad;
					}
			
                                        /* frickel, frickel frickel :) */
					m_move_pkthdr(n, m);
					m_copydata(m, 0, len, buf);
				        m_freem(m);
					
                                        if (!m_append(n, len, buf)) {
						m_freem(n);
						err = ENOBUFS; 
						goto bad;
					}	
						
					NG_FWD_NEW_DATA(err, item, dst->hook, n);
				} else 
					NG_FWD_NEW_DATA(err, item, dst->hook, m);			
			} else {
				if (sc->sc_orphan.hook) 
					NG_FWD_NEW_DATA(err, item, sc->sc_orphan.hook, m);
				else { 
                                        err = EINVAL;
				        goto bad;
                                } 
			}	
		}
	}
	
	return(err);
	
bad:	
	NG_FREE_M(m);
	if (item)
		NG_FREE_ITEM(item);
		
	return(err);
}
Ja was denn nun???

Oder mir ist bei naeherer Untersuchung von Quellcode, bspw. aus http://fxr.watson.org/fxr/source/net/if_clone.h?v=FREEBSD, folgende Konvention bzgl. Strukturen aufgefallen
Code: 
struct if_clone {
    ...
    const char * ifc_name;
    int ifc_maxunit;
    ...
};

Bei Artefakten bzw. Members wird in der namentlichen Bezeichnung ein Praefix aus den ersten Buchstaben der Betsandteile der Strukturbezeichnung gebildet.
Code: 
    Strukturname: if_clone => Membername: ifc_blablubb
dann begegne ich beim Quellcodestudium oftmals Strukturen, wo diese Konvention nicht gelten vermag. Ist die o.g. Form namentlicher Bezeichnung willkuerlich oder hat dies einen speziellen Hintergrund bzw. eine spezifische Systematik, der irgendeiner (mir logischerweise unbekannten) Industrienorm zugrundeliegt? (Wenn ja, welche??? Wo kann ich diesbezueglich Informationen abschoepfen?). Usw.Usf.

Literaturtips?

Ich will mir das noetige Wissen und Erfahrung erarbeiten, um mich in den Zustand zu versetzen, dem FreeBSD Projekt einen sinnvollen Beitrag leisten zu koennen.
 
Zuletzt bearbeitet von einem Moderator:
Zu goto's, die werden oft als Ersatz für die fehlenden Exceptions verwendet. Das sieht man auch im FreeBSD Code häufig, ich würde es nicht machen.

In State-Machines halte ich die Verwendung von goto aber für legitim. Ist aber nur von Vorteil, wenn die STM getaktet aufgerufen wird und man von einem Zustand ohne warten zum nächsten will.
 
Kamikaze schrieb:
In State-Machines halte ich die Verwendung von goto aber für legitim. Ist aber nur von Vorteil, wenn die STM getaktet aufgerufen wird und man von einem Zustand ohne warten zum nächsten will.
Zum Vergrößern anklicken....

Interessant, d.h. Variante 2 wäre (hier) zu bevorzugen, da diese Netgraphmethode (ja ich weis, das ist eine Funktion, aber netgraph(4) definiert sich als objektorientiertes Subsystem) einen auf einem spezifischen, bliebigen Port eines OSI-L2 Switch anfallenden Datenstrom nach Rahmentyp demultiplexiert, wenn vom Downstream einer ng_ether assoziierten Instanz Rahmen in diesen Netgraph Knoten eintreten.

Ich suche im speziellen nach Literatur (*), welche sich mit Programmierpraxis bzgl. Unix Systemprogrammierung tiefer auseinandersetzt im Hinblick auf spezifische Industrienormen bzgl. Betriebssystemarchitektur und -design aus Sicht von Softwareentwicklung.

Seit geraumer Zeit habe ich mir einge Ideen in den Kopf gesetzt, die ich unbedingt als BSD KMods implementieren möchte (bspw. spiele ich mit dem Gedanken, seit geraumer Zeit, ein Modul mit der Zielsetzung die bzgl. http://fxr.watson.org/fxr/source/net/if_llc.h?v=FREEBSD9 bzw. IEEE 802.2 einen LLC Socket zu implementieren, ich denke Devices zu exportieren via geom_gate per LLC (als Ergaenzung zur derzeitigen Verfahrensweise, also TCP/IP) waere vielleicht eine nette Alternative zu ATAoE, als nette kleine vertraeumte Experimentiererei - genug getraeumt, langsam werde ich groeszenwahnsinnig :ugly: ).




----
(*) Die von Joseph Kong geschriebene Literatur habe ich bereits gelesen sowie "Design and Implementation of the FreeBSD Operating System" von Dr. Kirk Marshal McKusick, "TCP/IP Illustrated Vol.2" habe ich ebenso schon mir vergegenwaertigt.
 
Zuletzt bearbeitet von einem Moderator:
darktrym schrieb:
Sowas wie Misra?
Zum Vergrößern anklicken....

Geil! Damit kann ich doch was anfangen. *freu*

Derartige Spezifikationen und Lektuere suche ich. Ich gehe davon mal aus, dasz dir defintiv noch mehr derartige Standards bekannt sind. Kannst du mir noch mehr empfehlen? Speziell suche ich Informationen bzgl. Fernmelde- und Telekommunikationssystemen.

Ich befinde mich quasi in einer Wueste auf der suche nach einem rettenden Wasserloch. *heul*.
 
Zuletzt bearbeitet von einem Moderator:
Kamikaze schrieb:
Ich habe eine Weile überlegt ob es ethisch akzeptabel ist Leute öffentlich bloßzustellen.
Zum Vergrößern anklicken....

Ist es nicht.

Dieser Thread ist wie folgende, fiktive Szene wie sie in jedem beliebigen Kindergarten passieren könnte: Ein paar Kinder, alle leidenschaftliche Fahrradfahrer, machen sich lustig über einen Neuzugang der nicht oder nur schlecht Fahrrad fährt. Die Tatsache, dass dieses Kind stattdessen Schlittschuhfahren kann wie ein junger Gott, wird dabei völlig ausgeblendet.

Die Attitüde die hier im Thread an den Tag gelegt wird empfinde ich als selbstverliebt und arrogant. Ich kann nichts Falsches darin erkennen jemanden um Hilfe zu bitten, egal in welchem Bereich oder zu welchem Thema. Etwas nicht zu wissen oder bisher noch nicht gelernt zu haben ist nichts Verwerfliches.

Sich dagegen in einem anderen Forum hinzustellen, die Fragesteller "öffentlich bloßstellen", Links zu eigenen Codefragmenten zu posten und den Vergleich zu suchen, das halte ich für fragwürdig.
 
das.chaos schrieb:
Die Diskussion ist ja ganz nett, aber kann mir mal bitte Irgendjemand stichpunktartig (als Aufzaehlung) definieren, was denn genau "guter" bzw. "schlechter" C code denn sei?
Zum Vergrößern anklicken....

Ich denke, dass das nicht möglich ist. Meiner Meinung nach ist Programmieren eine, Software zu entwickeln eine andere Sache. Ersteres ist mit überschaubarem Aufwand lernbar und wird vieler Orts auch getan. Was letzteres betrifft, so denke ich dass es kein Zufall ist, dass es ganze Studiengänge über Softwaretechnik gibt. Was guter oder schlechter Code ist hängt von vielen äußeren Faktoren ab, so dass es für die Frage keine allgemeingültige Antwort geben kann.
 
Vincent Vega schrieb:
Ist es nicht.

Dieser Thread ist wie folgende, fiktive Szene wie sie in jedem beliebigen Kindergarten passieren könnte: Ein paar Kinder, alle leidenschaftliche Fahrradfahrer, machen sich lustig über einen Neuzugang der nicht oder nur schlecht Fahrrad fährt. Die Tatsache, dass dieses Kind stattdessen Schlittschuhfahren kann wie ein junger Gott, wird dabei völlig ausgeblendet.

Die Attitüde die hier im Thread an den Tag gelegt wird empfinde ich als selbstverliebt und arrogant. Ich kann nichts Falsches darin erkennen jemanden um Hilfe zu bitten, egal in welchem Bereich oder zu welchem Thema. Etwas nicht zu wissen oder bisher noch nicht gelernt zu haben ist nichts Verwerfliches.

Sich dagegen in einem anderen Forum hinzustellen, die Fragesteller "öffentlich bloßstellen", Links zu eigenen Codefragmenten zu posten und den Vergleich zu suchen, das halte ich für fragwürdig.
Zum Vergrößern anklicken....

Ich kann mich da nur anschließen.
 
Ich finde das alles andere als kindisch. Von einem KFZ Mechaniker erwarte ich auch, dass er wenigstens mit einem Schlüssel umgehen kann und nebenbei technisches Verständnis besitzt.
Auch programmieren erfordert neben der investierte Zeit auch Kritikfähigkeit, wenn ich meinen Code der Öffentlichkeit präsentiere. Viel zu häufig bekommt man heute nämlich das Gefühl, Programmieren lernen geht zwischen zwei Kaffeepausen oder es reicht gar ein halbes Semester um eine Sprache richtig zu verwenden. Und wenn einem die Basics fehlen, fehlt mir das Verständnis. Bin vielleicht auch zu alt, wenn ich zur der Generation gehöre die das entwicklen vom örtl. Bibliotheksbestand gelernt habe. Auch im Studium wird immer wieder auf Eigeniniative verwiesen, was offensichlich nicht allen Studenten entgegenkommt.
Erst diese Woche hat einer bei pl-berichte.de sein Projekt vorgestellt samt Quellcode, haarsträubend wie man die Leistung bewerben kann. Da frag' ich mich, ob er jemals ein PHP-Buch bis zum Ende durchgelesen hat.
 
Vincent Vega schrieb:
Ich denke, dass das nicht möglich ist. Meiner Meinung nach ist Programmieren eine, Software zu entwickeln eine andere Sache. Ersteres ist mit überschaubarem Aufwand lernbar und wird vieler Orts auch getan. Was letzteres betrifft, so denke ich dass es kein Zufall ist, dass es ganze Studiengänge über Softwaretechnik gibt. Was guter oder schlechter Code ist hängt von vielen äußeren Faktoren ab, so dass es für die Frage keine allgemeingültige Antwort geben kann.
Zum Vergrößern anklicken....

<loriot>
Ach!
</loriot>

:)

Dann habe ich mich falsch artikuliert - sorry! Ich suche nach Literatur, welche sich mit Namensraumkonvetionen bzgl. Unix Systementwicklung bschaeftigt. Praeziser, bspw. habe ich mir mal vor geraumer Zeit das Buch "Design Patterns" beschafft, gibt es aehnliche Literatur, welche sich spezifisch mit Betriebssystemarchitektur befasst (ich meine jetzt nicht "Modern Operating Systems" von Tannenbaum - das ist mir zu oberflaechlich)?

Wo kann ich mir eine Uebersicht gegebener Industriestandards, bspw. wie der bereits erwaehnte MISRA Standard (den ich mir jetzt bestellen werde, am Geld scheiterts nicht) verschaffen???

Als Student hat man leider wenig Informationsquellen diesbezueglich, wo man denn nun seine Recherchen starten sollte? Es ist schwierig nach etswa zu recherchieren, was man nicht namentlich kennt (oder kennen kann).
 
Zuletzt bearbeitet von einem Moderator:
Okay, und jetzt alle einmal tief ein- und wieder ausatmen ... und zurück zum Thema!

Bzgl. MISRA wäre sicher (zur Einhaltung) noch PC-lint (und Derivate) zu nennen. Für C ist mir nichts weiter (nennenswertes) bekannt.

Für C++ finde ich auch persönlich die Google Empfehlungen ganz gut:
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml

C++11 ist leider nicht nicht abgesegnet aus Google Sicht. Schade. Denn das war der Grund für mich mal C++ intensiver anzuschauen.

Kenne ich selbst zwar nicht, aber vielleicht gibt es in der IEC 61508 noch Empfehlungen?
 
Danke.

Ich gebe zu ich habe etwas das Thema mit OT gecrasht, daher habe ich entschieden eine Gesonderten Thread (oder wie man das nennt) @ Geekstuff > Programmieren zu eroeffnen.
 
Du musst dich einloggen oder registrieren, um hier zu antworten.
Zurück
Oben