Abo
  1. Foren
  2. Kommentare
  3. Security
  4. Alle Kommentare zum Artikel
  5. › Shellshock: Immer mehr Lücken in Bash

Das sagt uns ein bisschen was über Programmierer

  1. Thema

Neues Thema Ansicht wechseln


  1. Das sagt uns ein bisschen was über Programmierer

    Autor: twothe 28.09.14 - 09:40

    Der Code von Bash, so als Haupt-Shell aller mir bekannten Linux Distros, dürfte wohl bisher von etwas mehr als nur einem Programmierer gelesen worden sein. Trotzdem hat in Jahrzehnten niemand diese Sicherheitslücken entdeckt. Es bedarf erst jemand, der wirklich Ahnung hat, um Zusammenhänge zu entdecken, die vor ihm niemand erkannt hat.

    Das sagt mir ein bisschen was darüber, wie der durchschnittliche Programmierer mit Code umgeht.

  2. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: gboos 28.09.14 - 10:35

    Nein, jemand hat nur mal aus "Langeweile" versucht Spass zu haben und sich gefragt ob das geht bzw. hat fehlerhaft gescriptet und dann hat's zufaellig "POPPOP" gemacht.

    So entdeckt man die meisten solcher Fehler.

  3. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: twothe 28.09.14 - 10:59

    Der Artikel sagt:

    > Nach der ersten Aufregung fanden mehrere Personen weitere Probleme im Funktionsparser von Bash. Der Google-Entwickler Michał Zalewski, auch unter seinem Nickname Lcamtuf bekannt, warnt jetzt, dass noch weitere unbekannte Sicherheitslücken drohen.

    Das heißt man hat jetzt wohl mal ein paar Profis angesetzt nach dem ersten Schock, und siehe da was die alles finden.

  4. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: 476f6c656d 28.09.14 - 11:13

    Oder aber - nachdem man gemerkt hat, das der Code doch nicht genau das macht, was man erwartet hat - schaut man ihn sich schlicht noch einmal an.
    Offensichtlich war der Code über Jahre hinweg gut genug, so das sich niemand mehr damit beschäftigen musste. Auch das spricht für Codequalität.

    Oder schaust du dir, wenn du ein Programm entwickelst, immer wieder den Code von den Funktionen und Methoden an, die du in den Programm aufrufst? Und schaust du dir wirklich immer wieder den Code von den Librarys die du einbindest an?
    So etwas macht normal kein Mensch. Mit solchen dingen fängt man erst an, wenn etwas nicht so funktioniert wie in der Dokumentation steht.

  5. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: bstea 28.09.14 - 11:17

    "Dokumentation OSS" ... ne, da bastelt man sich ein Workaround, bevor ich eine halbwegs aktuelle Version finde, die auch brauchbar ist.

    --
    Erst wenn der letzte Baum gefällt, der letzte Fluss gestaut und der letzte Fisch gefangen ist, werdet ihr feststellen, dass man Biber nicht essen kann!

  6. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: twothe 28.09.14 - 12:13

    476f6c656d schrieb:
    --------------------------------------------------------------------------------
    > Offensichtlich war der Code über Jahre hinweg gut genug, so das sich
    > niemand mehr damit beschäftigen musste. Auch das spricht für Codequalität.

    Offensichtlich war die Codequalität über Jahre hinweg schlecht, aber es hat einfach niemanden interessiert.

    > Oder schaust du dir, wenn du ein Programm entwickelst, immer wieder den
    > Code von den Funktionen und Methoden an, die du in den Programm aufrufst?

    Ich nutze eine inkrementelle Modul Strategie, d.h. u.A. das Code so lange reviewed und modifiziert wird, bis individuelle Funktionen nachweislich fehlerfrei laufen.

    > Und schaust du dir wirklich immer wieder den Code von den Librarys die du
    > einbindest an?

    Alle Libraries die ich (beruflich) nutze werden erst mal einem ausführlichen Test unterzogen, der u.A. beinhaltet das man mal über den Code schaut (wenn möglich) um eine Einschätzung der Qualität der Library zu bekommen. Und wir haben nicht gerade wenig bisher wegen mangelnder Codequalität abgelehnt.

  7. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: gboos 28.09.14 - 15:50

    twothe schrieb:
    --------------------------------------------------------------------------------
    > 476f6c656d schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Offensichtlich war der Code über Jahre hinweg gut genug, so das sich
    > > niemand mehr damit beschäftigen musste. Auch das spricht für
    > Codequalität.
    >
    > Offensichtlich war die Codequalität über Jahre hinweg schlecht, aber es hat
    > einfach niemanden interessiert.
    >
    > > Oder schaust du dir, wenn du ein Programm entwickelst, immer wieder den
    > > Code von den Funktionen und Methoden an, die du in den Programm
    > aufrufst?
    >
    > Ich nutze eine inkrementelle Modul Strategie, d.h. u.A. das Code so lange
    > reviewed und modifiziert wird, bis individuelle Funktionen nachweislich
    > fehlerfrei laufen.
    >
    > > Und schaust du dir wirklich immer wieder den Code von den Librarys die
    > du einbindest an?
    >
    > Alle Libraries die ich (beruflich) nutze werden erst mal einem
    > ausführlichen Test unterzogen, der u.A. beinhaltet das man mal über den
    > Code schaut (wenn möglich) um eine Einschätzung der Qualität der Library zu
    > bekommen. Und wir haben nicht gerade wenig bisher wegen mangelnder
    > Codequalität abgelehnt.

    Das Funktionen nachweislich einwandfrei laufen heisst ja nicht das sie Bug-frei sind. Dein "WENN MOEGLICH" war echt niedlich. Erklaert alles ;)

  8. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: pythoneer 28.09.14 - 17:18

    twothe schrieb:
    --------------------------------------------------------------------------------
    > Ich nutze eine inkrementelle Modul Strategie, d.h. u.A. das Code so lange
    > reviewed und modifiziert wird, bis individuelle Funktionen nachweislich
    > fehlerfrei laufen.

    Dann scheint ihr ja große Fans von Hoare und dessen Kalkül zu sein, anders (oder ähnlich) kann man die Korrektheit nämlich gar nicht nachweisen und selbst wenn man dies getan hat, kann immer noch die Spezifikation falsch sein. Ja ihr scheint euch Mühe zu geben, wer aber seinen Code in Verbindung mit dem Wort fehlerfrei verwendet, leidet unter gesunder Selbstüberschätzung. Gesund deswegen, weil man dann hoffentlich bald seinen Job los ist, denn in dem hätte man wohl nichts zu suchen.

  9. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: salemcmr 28.09.14 - 18:17

    twothe schrieb:
    --------------------------------------------------------------------------------
    > 476f6c656d schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Offensichtlich war der Code über Jahre hinweg gut genug, so das sich
    > > niemand mehr damit beschäftigen musste. Auch das spricht für
    > Codequalität.
    >
    > Offensichtlich war die Codequalität über Jahre hinweg schlecht,

    es hat 25 Jahre gebraucht bis jemand einen fehler gefunden hat der vor 25 Jahren entstanden ist... wenn es solange braucht kann man da wirklich von schlechten Code sprechen oder spricht das eher für das Sicherheitskonzept in unixoiden Betriebssystemen, denn 25Jahre sind kein Pappenstiel, da will man garnicht drüber nachdenken was da noch in bei MS so lauert.

    > aber es hat einfach niemanden interessiert.

    doch hat es, sonst wären aus 25 Jahren, 26, 27 und mehr Jahre geworden ...

  10. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: elgooG 28.09.14 - 19:08

    salemcmr schrieb:
    --------------------------------------------------------------------------------
    > es hat 25 Jahre gebraucht bis jemand einen fehler gefunden hat der vor 25
    > Jahren entstanden ist... wenn es solange braucht kann man da wirklich von
    > schlechten Code sprechen oder spricht das eher für das Sicherheitskonzept
    > in unixoiden Betriebssystemen, denn 25Jahre sind kein Pappenstiel, da will
    > man garnicht drüber nachdenken was da noch in bei MS so lauert.

    /+1

    Wenn man bedenkt wie intensiv und umfangreich die BASH bisher über 2 Jahrzehnte benutzt wurde, kann man tatsächlich nur Respekt davor haben, das erst jetzt jemand etwas gefunden hat.

    BTW: Seriöse Entwickler behaupten nicht, dass ihr Code fehlerfrei ist, weil sie wissen, dass er es nicht ist, oder externe Codes ihn dennoch negativ beeinflussen können. Das hier ist doch die beste Demonstration dafür, wie ein millionenfach getesteter und verwendeter Code dennoch kritische Fehler enthalten kann. Noch dazu wird die BASH nicht von Safttüten, sondern von vielen verschiedenen Experten bei der täglichen Arbeit verwendet. Mit bestimmten Entwicklungsmethoden kann man eben immer nur die Wahrscheinlichkeit von Fehlern ein wenig reduzieren, aber nie alle völlig beseitigen.

    Kann Spuren von persönlichen Meinungen, Sarkasmus und Erdnüssen enthalten. Ausdrucke nicht für den Verzehr geeignet. Ungelesen mindestens haltbar bis: siehe Rückseite

  11. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: furburlong 28.09.14 - 19:36

    Es wird schon genug Leute gegeben haben, die sich den Code angeschaut haben. Sicherheitslücken finden ist allerdings schwer und es gibt keinen Weg, der immer zum Ziel führt. Wenns so einfach wäre, dann gäbe es keine Lücken mehr.

  12. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: SelfEsteem 28.09.14 - 19:40

    twothe schrieb:
    --------------------------------------------------------------------------------
    > 476f6c656d schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Offensichtlich war der Code über Jahre hinweg gut genug, so das sich
    > > niemand mehr damit beschäftigen musste. Auch das spricht für
    > Codequalität.
    >
    > Offensichtlich war die Codequalität über Jahre hinweg schlecht, aber es hat
    > einfach niemanden interessiert.
    >
    > > Oder schaust du dir, wenn du ein Programm entwickelst, immer wieder den
    > > Code von den Funktionen und Methoden an, die du in den Programm
    > aufrufst?
    >
    > Ich nutze eine inkrementelle Modul Strategie, d.h. u.A. das Code so lange
    > reviewed und modifiziert wird, bis individuelle Funktionen nachweislich
    > fehlerfrei laufen.
    >
    > > Und schaust du dir wirklich immer wieder den Code von den Librarys die
    > du
    > > einbindest an?
    >
    > Alle Libraries die ich (beruflich) nutze werden erst mal einem
    > ausführlichen Test unterzogen, der u.A. beinhaltet das man mal über den
    > Code schaut (wenn möglich) um eine Einschätzung der Qualität der Library zu
    > bekommen. Und wir haben nicht gerade wenig bisher wegen mangelnder
    > Codequalität abgelehnt.

    Ach du heilige Schei.., mal wieder so'n inkompetenter Schwätzer.
    Da guckt also nochmal jemand drauf auf die Funktion, die dann aber eh schon nachweislich fehlerfrei laufen, hm? Ich höre genau dieses Geschwätz immer wieder von Leuten, die dann aber den schwächsten Code abliefern.

    Persönliches Highlight von letzter Woche von einem Schnösel, der auch immer total geilen, nachweislich fehlerfreien Code schreibt: "Ja woher soll ich denn wissen, dass der Compiler sich da so verhält - is ja jetzt nicht meine Schuld".

    Langer Rede kurzer Sinn: Ball flachhalten, wenn man von Tuten und Blasen keinen Schimmer hat und schon so weit ist mit "bei uns guckt da noch mal einer drauf" argumentieren muss ...

  13. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: bstea 28.09.14 - 19:52

    Wie kommst du auf die Idee, dass das millionenfach getestet wurde?
    Ein Entwickler testet doch seinen eigenen Code und nicht den der ausführenden Engine.

    --
    Erst wenn der letzte Baum gefällt, der letzte Fluss gestaut und der letzte Fisch gefangen ist, werdet ihr feststellen, dass man Biber nicht essen kann!

  14. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: twothe 28.09.14 - 20:09

    SelfEsteem schrieb:
    --------------------------------------------------------------------------------
    > Langer Rede kurzer Sinn: Ball flachhalten, wenn man von Tuten und Blasen
    > keinen Schimmer hat und schon so weit ist mit "bei uns guckt da noch mal
    > einer drauf" argumentieren muss ...

    Da musste ich jetzt schon ein bisschen schmunzeln. Gut das du mich so gut kennst das du sogar besser weißt was in meinem Leben so passiert als ich. ;)

    Ich weiß nicht genau warum du deinem Ärger hier so Luft machen musst, aber es ist hilfreich wenn man da nach einer Lösung sucht, wo das tatsächliche Problem ist.

  15. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: SelfEsteem 28.09.14 - 20:38

    twothe schrieb:
    --------------------------------------------------------------------------------
    > SelfEsteem schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > Langer Rede kurzer Sinn: Ball flachhalten, wenn man von Tuten und Blasen
    > > keinen Schimmer hat und schon so weit ist mit "bei uns guckt da noch mal
    > > einer drauf" argumentieren muss ...
    >
    > Da musste ich jetzt schon ein bisschen schmunzeln. Gut das du mich so gut
    > kennst das du sogar besser weißt was in meinem Leben so passiert als ich.
    > ;)
    Da kannst du ziemlich lange schmunzeln und ich bin total überzeugt davon, dass dein Leben super interessant ist ... vielleicht ... fuer jemanden, der was drauf gibt.
    Hier und jetzt liegt aber nur im Raum, dass du voellig schwachsinnige Erguesse in den Raum wirfst ("also bei uns guckt so oft nochmal jemand drauf, bis definitv kein Fehler mehr drin ist, ja wohl ja, total sicher und so") und damit Entwickler kritisierst, die zwar definitiv Mist gebaut haben, deren Versagen aber wohl immerhin noch auf einem für dich immernoch unerreichbaren Niveau liegen dürfte.

    Und nein, das ist kein Ärger - ich kann das ständige "ba sind die schlecht, ich bin besser, ich lese meinen Code nochmal quer" von irgendwelchen Amateuren schlicht nicht mehr hören und mag niederschreiben, wie sehr ich es nicht hören kann - Ärger sieht jedoch anders aus.

    > Ich weiß nicht genau warum du deinem Ärger hier so Luft machen musst, aber
    > es ist hilfreich wenn man da nach einer Lösung sucht, wo das tatsächliche
    > Problem ist.
    Die Lösung wäre, dass irgendwelche Amateure gelegentlich mal ein Buch lesen und nicht mit derartiger Grütze versuchen zu argumentieren.
    Vielen Dank an dieser Stelle für das Angebot mir zu helfen ....



    1 mal bearbeitet, zuletzt am 28.09.14 20:40 durch SelfEsteem.

  16. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: twothe 29.09.14 - 09:59

    SelfEsteem schrieb:
    --------------------------------------------------------------------------------
    > Und nein, das ist kein Ärger - ich kann das ständige "ba sind die schlecht,
    > ich bin besser, ich lese meinen Code nochmal quer" von irgendwelchen
    > Amateuren schlicht nicht mehr hören und mag niederschreiben, wie sehr ich
    > es nicht hören kann - Ärger sieht jedoch anders aus.

    Deinen Gedankengang kann ich nicht nachvollziehen. Ich habe einfach nur akzeptiert, dass Bugs zum Programmieren dazu gehören, und dementsprechend den Arbeitsablauf gestaltet. Code wird nicht einfach geschrieben und dann eingechecked, sondern er wird inkrementell geschrieben und in jeder Iteration ausführlich getestet. Sobald ein Code-Teil für gut befunden wurde, wird dieser danach nicht mehr geändert (bzw. wenn doch, dann muss er neu getestet werden). Erfüllt auch das Kriterium: Um Code testen zu können muss er testbar sein.

    Und obendrauf kommt noch ein QA Team, denen ich von Anfang an gesagt habe, dass deren Job ist jede noch so kleine Stelle gründlichst zu testen, und wenn irgendein Programmierer sagt "Das braucht ihr nicht testen, das ist von mir" dann doppelt so gut testen. Und so lange auf die Füße treten bis wirklich alle Bugreports gefixed sind.

    Das zieht sich am Anfang etwas, und ich musst auch etwas Überzeugungsarbeit beim Chef leisten, aber das lohnt sich halt auf lange Sicht, wenn man auf ein mal keine ungeplanten 2 Monate extra für Tests und Bugfixing braucht, weil das alles schon erledigt ist. Und als wir dann nach 2 Jahren das einzige Team ohne Serverausfall, kritischem Bug oder Downtime wegen Hotfix waren, waren alle zufrieden inklusive der Kunden.

  17. Re: Das sagt uns ein bisschen was über Programmierer

    Autor: theonlyone 29.09.14 - 10:50

    SelfEsteem schrieb:
    --------------------------------------------------------------------------------
    > twothe schrieb:
    > ---------------------------------------------------------------------------
    > -----
    > > SelfEsteem schrieb:
    > >
    > ---------------------------------------------------------------------------
    >
    > > -----
    > > > Langer Rede kurzer Sinn: Ball flachhalten, wenn man von Tuten und
    > Blasen
    > > > keinen Schimmer hat und schon so weit ist mit "bei uns guckt da noch
    > mal
    > > > einer drauf" argumentieren muss ...
    > >
    > > Da musste ich jetzt schon ein bisschen schmunzeln. Gut das du mich so
    > gut
    > > kennst das du sogar besser weißt was in meinem Leben so passiert als
    > ich.
    > > ;)
    > Da kannst du ziemlich lange schmunzeln und ich bin total überzeugt davon,
    > dass dein Leben super interessant ist ... vielleicht ... fuer jemanden, der
    > was drauf gibt.
    > Hier und jetzt liegt aber nur im Raum, dass du voellig schwachsinnige
    > Erguesse in den Raum wirfst ("also bei uns guckt so oft nochmal jemand
    > drauf, bis definitv kein Fehler mehr drin ist, ja wohl ja, total sicher und
    > so") und damit Entwickler kritisierst, die zwar definitiv Mist gebaut
    > haben, deren Versagen aber wohl immerhin noch auf einem für dich immernoch
    > unerreichbaren Niveau liegen dürfte.
    >
    > Und nein, das ist kein Ärger - ich kann das ständige "ba sind die schlecht,
    > ich bin besser, ich lese meinen Code nochmal quer" von irgendwelchen
    > Amateuren schlicht nicht mehr hören und mag niederschreiben, wie sehr ich
    > es nicht hören kann - Ärger sieht jedoch anders aus.
    >
    > > Ich weiß nicht genau warum du deinem Ärger hier so Luft machen musst,
    > aber
    > > es ist hilfreich wenn man da nach einer Lösung sucht, wo das
    > tatsächliche
    > > Problem ist.
    > Die Lösung wäre, dass irgendwelche Amateure gelegentlich mal ein Buch lesen
    > und nicht mit derartiger Grütze versuchen zu argumentieren.
    > Vielen Dank an dieser Stelle für das Angebot mir zu helfen ....

    Was er im groben schreibt ist ja praktisch Test-Driven zu entwickeln, zu jedem Code erstmal Tests schreiben, dazu den Code.

    Das kombiniert man mit X-Treme Programming, hat man immer Pair-Programming, immer ein Code-Review. Die Test-Abdeckung kann damit in der Tat 100% sein, aber das ist eben nur eine Abdeckung, die sagt nicht das es keine Fehler gibt, man testet eben nur das was man testen will, sprich hoffentlich alles was Spezifiziert ist sollte auch einen Test haben, der prüft das genau diese Anforderung auch funktioniert // zumindest unter den Test-Bedingungen, wie das im Realen Betrieb aussieht, schon wieder eine ganz andere Sache (den da kommen zusätzlich probleme dazu, externe Services, die Festplatte läuft voll, die Datenbank hängt sich auf, was auch immer, daran hängt dann der eigene Code, obwohl der Fehler woanders liegt ; Resultat, gerade für Produktiv Systeme bei denen SOFORT eine Lösung her muss, hat der Code dann einfach Hotfixes, die sporadisch getestet werden, sie haben vielleicht einige Unit Tests, aber die sagen immer nur so viel aus, wie sie auch wirklich testen).


    Demnach, es macht ohne Frage Sinn seinen Code immer schön mit Unit Tests abzudecken. Eine Feature sollte immer einen Test haben der zeigt das es funktioniert (und die ganz üblichen Patzer prüft, sprich Null-Pointer, Parameter als Null, jede Exception die man wirft einmal erzwingen).

    Was man NICHT testet ist das Grund-System. In java wird man in seinen unit Tests ganz sicher nicht die VM testen, die "muss" funktionieren, hat die Bugs, dann hat das mit dem eigenen Code "primär" nichts zu tun / auch wenn man sich um einen Workaround bemühen muss.


    Code-Reviews sind auch ohne Frage sinnvoll. Zum einen damit man kleine Patzer direkt erkennt, den sein wir ehrlich, viele Kleinigkeiten fallen einer 2ten person direkt auf, einem selbst aber nicht, auch nach 10 mal drüber fliegen.
    Zum anderen hilft Code-Review dem Team eine bessere Übersicht zu bekommen, wer was geschrieben hat, WARUM der Code so aussieht und im Endeffekt verstreut man sein Wissen auf mehrere Personen, anstatt 1 Guru der sich auskennt und der Rest hat keine Ahnung was der geschrieben hat.


    Die ganzen Tests sind spätestens dann wirklich wichtig, wenn der Code Refactored wird, oder schlicht neue Features dazu kommen.
    Bei vielen Veteranen (20+ Jahre Erfahrung) existiert ja durchaus die Mentalität das guter Code nicht getestet werden muss, ganz im Sinne von : "Wir wissen was wir machen, wir verschwenden keine Zeit zum Testen, das macht das Test-Team".
    Tja, da steht und fällt dann alles mit dem Test-Team, das sucht aber nicht im Source Code selbst nach Fehlern, demnach ist das ein ganz gefährliches Eisen ; aber selbst so etwas funktioniert, man braucht eben dann eine Truppe von Gurus die in der Tat Code runterschreiben der "sehr oft" direkt funktioniert, oder Fehler auch schnell lösen können.

    Richtig problematisch wird es eben, wenn sich diese Welten kombinieren sollen. Auf der einen Seite der Guru und dann ein paar Leute die Test-Driven sein wollen. Das ergibt immer Zündstoff und das funktioniert schlichtweg nicht.

  1. Thema

Neues Thema Ansicht wechseln


Um zu kommentieren, loggen Sie sich bitte ein oder registrieren Sie sich. Zum Login

Stellenmarkt
  1. EnBW Energie Baden-Württemberg AG Holdin, Karlsruhe
  2. Berliner Verkehrsbetriebe (BVG), Berlin
  3. CompuGroup Medical SE, Kiel, Hamburg
  4. we.CONECT Global Leaders GmbH, Berlin-Kreuzberg,Berlin

Golem pur
  • Golem.de ohne Werbung nutzen

Anzeige
Spiele-Angebote
  1. (-75%) 3,75€
  2. 1,72€
  3. 2,99€
  4. (-80%) 1,99€


Haben wir etwas übersehen?

E-Mail an news@golem.de


Ryzen 3900X/3700X im Test: AMDs 7-nm-CPUs lassen Intel hinter sich
Ryzen 3900X/3700X im Test
AMDs 7-nm-CPUs lassen Intel hinter sich

Das beste Prozessor-Design seit dem Athlon 64: Mit den Ryzen 3000 alias Matisse bringt AMD sehr leistungsstarke und Energie-effiziente CPUs zu niedrigen Preisen in den Handel. Obendrein laufen die auch auf zwei Jahre alten sowie günstigen Platinen mit schnellem DDR4-Speicher.
Ein Test von Marc Sauter

  1. Ryzen 3000 BIOS-Updates schalten PCIe Gen4 für ältere Boards frei
  2. Mehr Performance Windows 10 v1903 hat besseren Ryzen-Scheduler
  3. Picasso für Sockel AM4 AMD verlötet Ryzen 3400G für flottere iGPU

In eigener Sache: Golem.de bietet Seminar zu TLS an
In eigener Sache
Golem.de bietet Seminar zu TLS an

Der Verschlüsselungsexperte und Golem.de-Redakteur Hanno Böck gibt einen Workshop zum wichtigsten Verschlüsselungsprotokoll im Netz. Am 24. und 25. September klärt er Admins, Pentester und IT-Sicherheitsexperten in Berlin über Funktionsweisen und Gefahren von TLS auf.

  1. In eigener Sache Zweiter Termin für Kubernetes-Seminar
  2. Leserumfrage Wie können wir dich unterstützen?
  3. In eigener Sache Was du schon immer über Kubernetes wissen wolltest

In eigener Sache: Neue Workshops zu agilem Arbeiten und Selbstmanagement
In eigener Sache
Neue Workshops zu agilem Arbeiten und Selbstmanagement

Wir haben in unserer Leserumfrage nach Wünschen für Weiterbildungsangebote gefragt. Hier ist das Ergebnis: Zwei neue Workshops widmen sich der Selbstorganisation und gängigen Fehlern beim agilen Arbeiten - natürlich extra für IT-Profis.

  1. In eigener Sache ITler und Board kommen zusammen
  2. In eigener Sache Herbsttermin für den Kubernetes-Workshop steht
  3. Golem Akademie Golem.de startet Angebote zur beruflichen Weiterbildung

  1. Streaming: Netflix' Kundenwachstum geht zurück
    Streaming
    Netflix' Kundenwachstum geht zurück

    Netflix hat im zweiten Quartal die eigenen Erwartungen verfehlt. Auch der Gewinn fiel niedriger aus als im Vorjahresquartal.

  2. Coradia iLint: Alstoms Brennstoffzellenzüge bewähren sich
    Coradia iLint
    Alstoms Brennstoffzellenzüge bewähren sich

    Zwei Züge, 100.000 Kilometer, keine Probleme: Nach zehn Monaten regulärem Einsatz in Niedersachsen ist das französische Unternehmen Alstom zufrieden mit seinen Brennstoffzellenzügen.

  3. Matternet: Schweizer Post pausiert Drohnenlieferungen nach Absturz
    Matternet
    Schweizer Post pausiert Drohnenlieferungen nach Absturz

    Blutkonserven oder Gewebeproben müssen unter Umständen schnell zu ihrem Bestimmungsort gebracht werden. Die Schweizer Post setzt für solche Transporte Drohnen ein. Doch nach vielen problemlosen Flüge ist ein Copter abgestürzt. Das Drohnenprogramm wurde daraufhin vorerst gestoppt.


  1. 23:00

  2. 19:06

  3. 16:52

  4. 15:49

  5. 14:30

  6. 14:10

  7. 13:40

  8. 13:00