<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
  <channel>
    <title>Ubuntuusers-Planet on svij | Sujeevan Vijayakumaran</title>
    <link>https://svij.org/tags/ubuntuusers-planet/</link>
    <description>Recent content in Ubuntuusers-Planet on svij | Sujeevan Vijayakumaran</description>
    <generator>Hugo -- gohugo.io</generator>
    <language>de</language>
    <managingEditor>mail@svij.org (Sujeevan Vijayakumaran)</managingEditor>
    <webMaster>mail@svij.org (Sujeevan Vijayakumaran)</webMaster>
    <lastBuildDate>Sun, 11 Feb 2024 10:50:00 +0100</lastBuildDate>
    
        <atom:link href="https://svij.org/tags/ubuntuusers-planet/index.xml" rel="self" type="application/rss+xml" />
    
    
    <item>
      <title>Warum man keine Fachbücher schreiben sollte …</title>
      <link>https://svij.org/blog/2024/02/11/warum-man-keine-fachb%C3%BCcher-schreiben-sollte/</link>
      <pubDate>Sun, 11 Feb 2024 10:50:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2024/02/11/warum-man-keine-fachb%C3%BCcher-schreiben-sollte/</guid>
      <description>&lt;p&gt;… und warum und wie ich es trotzdem tat.&lt;/p&gt;
&lt;p&gt;Vor wenigen Wochen habe ich mein zweites Fachbuch fertiggestellt. In diesem Blogpost gehe ich ein wenig tiefer ein, was meine Motivation war, wie sich der Fortschritt gestaltet hat und welche Hilfsmittel (nicht) geholfen haben.&lt;/p&gt;
&lt;p&gt;Bücher schreiben klingt für viele total toll. Die Realität fühlte sich häufig allerdings das Meme oben an …&lt;/p&gt;
&lt;h2 id=&#34;rückblick&#34;&gt;Rückblick&lt;/h2&gt;
&lt;p&gt;Vor langer Zeit fing ich hier auf meinem Blog eine vierteilige Tutorial-Reihe zu Git an. &lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/&#34;&gt;Der erste Blogpost&lt;/a&gt; erschien im Oktober 2014. Das ist jetzt auch schon fast zehn Jahre her. Meine damalige Intention war recht einfach: Ich hatte Lust etwas über das Thema zu schreiben, denn ich bekam sowohl bei der Arbeit, als auch bei der Mitarbeit in Open-Source-Projekten ständig Fragen, wie dieses Git denn nun funktioniert. Da ich keine Lust hatte, es immer wieder zu erklären, schrieb ich es eben einmal ordentlich runter und verlinkte diese Blog-Posts und beantwortete erst später konkretere Fragen.&lt;/p&gt;
&lt;p&gt;Durch eine Verkettung von Umständen kam es dann dazu, dass ich die Möglichkeit hatte, ein Buch über Git zu schreiben. Diese vier Artikel dienten als Basis für das Buch, wo ich natürlich dann sehr sehr viel erweitert habe. Zwei Jahre später im August 2016, erschien dann &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/&#34;&gt;die erste Auflage meines Git-Buches&lt;/a&gt; beim mitp-Verlag. Im Mai 2019 folgte &lt;a href=&#34;https://svij.org/blog/2019/05/10/zweite-auflage-meines-git-buches-erschienen/&#34;&gt;die zweite Auflage&lt;/a&gt;, im März 2021 &lt;a href=&#34;https://svij.org/blog/2021/03/03/dritte-auflage-meines-git-buches-erschienen/&#34;&gt;die dritte&lt;/a&gt; und im März 2022 folgte der &lt;a href=&#34;https://svij.org/blog/2022/03/31/neues-buch-git-schnelleinstieg/&#34;&gt;Git Schnelleinstieg&lt;/a&gt; als abgespeckte Variante. Über die vergangenen 7,5 Jahre verkauften sich knapp über 4000 Exemplare.&lt;/p&gt;
&lt;h3 id=&#34;die-vor--und-nachteile-des-autorendaseins&#34;&gt;Die Vor- und Nachteile des Autorendaseins&lt;/h3&gt;
&lt;p&gt;Ein Buch geschrieben zu haben, hat sowohl diverse Vor- als auch Nachteile. Jedes Mal, wenn mir jemand Anfängerfragen zu Git gestellt hat, folgte von mir ein stark ironisches „Also … ich kann dir da ein Buch empfehlen“. Das war immer wieder zur Aufheiterung lustig. Was ich meistens nicht so geil fand, waren Random Gespräche bei Feiern jeglicher Art. Da wurde man plötzlich von Freunden, Bekannten und Verwandten anderen Personen als Autor vorgestellt … was dazu geführt hat, dass ich ständig wildfremden Leuten, die &lt;em&gt;nicht&lt;/em&gt; in der IT sind, erklären musste, was denn diese Versionsverwaltung mit Git ist. Meistens sah ich nach zwei oder drei Sätzen schon, wie sie bei meinem Versuch es zu erklären, ausgestiegen sind, aber natürlich empfanden sie es als super und toll! Spaß macht das nicht. Außerdem ist scheinbar „Buch schreiben“ ein Bucketlist-Item für viele Leute. Ich weiß bis heute nicht, warum, aber ich muss auch nicht alles verstehen.&lt;/p&gt;
&lt;p&gt;Wer übrigens etwas näher hören will, wie so ein Buch entsteht, darüber habe ich in der &lt;a href=&#34;https://tilpod.net/episode/til002-ueber-das-fachbuecher-schreiben&#34;&gt;zweiten Folge unseres Podcasts TILpod&lt;/a&gt; von und mit Dirk Deimeke gesprochen.&lt;/p&gt;
&lt;h3 id=&#34;ursprüngliche-motivation--umsetzung&#34;&gt;Ursprüngliche Motivation &amp;amp; Umsetzung&lt;/h3&gt;
&lt;p&gt;Zurück zur Motivation und der Umsetzung: Nachdem ich die ursprünglichen Blogposts ohne tieferen Hintergedanken geschrieben habe, war das bei einem Buch natürlich etwas anderes. Die Qualitätsansprüche sind hier natürlich deutlich höher, denn hier bezahlen die Kunden mit Geld. Von diesem Geld blieb allerdings nicht sehr viel in meinem Geldbeutel hängen. Dass man als Autor nicht reich wird, war mir bewusst.&lt;/p&gt;
&lt;p&gt;Eine gewisse Reputation und ein „einfacherer“ Einstieg in idealerweise gut bezahlten Job mit guten Arbeitsbedingungen war mein Hauptmotivationstreiber. 2015, als ich mit der Arbeit am Buch begann, war ich gerade erst mit dem Bachelor fertig. Die darauffolgenden Jobwechsel waren beim Hinblick auf Gehalt, Arbeitsbedingungen und Interessantheit der Tätigkeiten alle nicht so das wahre (in verschiedenen Konstellationen).&lt;/p&gt;
&lt;p&gt;Long story short: Im April 2020 fing ich meinen Job als &lt;a href=&#34;https://handbook.gitlab.com/job-families/sales/solutions-architect/&#34;&gt;Solutions Architect&lt;/a&gt; bei &lt;a href=&#34;https://about.gitlab.com&#34;&gt;GitLab&lt;/a&gt; an. Zu den ausgeschriebenen Jobs bei GitLab hatte ich ohnehin schon seit einigen Jahren einen Blick geworfen und dann hat es auch auf Anhieb geklappt. Ein deutlicher Gehaltssprung war dabei, deutlich bessere Arbeitsbedingungen und auch die Tätigkeit im Pre-Sales, was ich so vorher auch nie gemacht habe, hat super gepasst. Mein Plan ging also einige Jahre später auf: Durch das Git-Buch habe ich mich deutlich tiefer in Git und dem gesamten Software-Delivery-Lifecycle eingearbeitet, sodass ich mich für den Job qualifizieren konnte.&lt;/p&gt;
&lt;p&gt;Soweit so gut. Ein Grund für ein komplett neues Buch brauchte ich eigentlich nicht … oder? &lt;strong&gt;Oder?&lt;/strong&gt;&lt;/p&gt;
&lt;h2 id=&#34;motivation-für-das-zweite-buch&#34;&gt;Motivation für das zweite Buch&lt;/h2&gt;
&lt;p&gt;Tja, ich wäre nicht ich, wenn ich immer wieder ein größeres Projekt angehen würde.&lt;/p&gt;
&lt;h3 id=&#34;fachliche-motivation&#34;&gt;Fachliche Motivation&lt;/h3&gt;
&lt;p&gt;Zunächst zur fachlichen Motivation: In tagtäglichen Gesprächen mit diversen (potenziellen) Kunden von GitLab merkte ich primär eins: Viele fokussieren sich viel zu stark auf die eingesetzten Tools – etwa GitLab –, ohne jedoch zu schauen, ob und wie „kaputt“ die Arbeitskultur ist.&lt;/p&gt;
&lt;p&gt;GitLab selbst positioniert sich als ganzheitliche &lt;a href=&#34;https://about.gitlab.com/solutions/devops-platform/&#34;&gt;DevOps-Plattform&lt;/a&gt;, womit man einfacher und schneller Projekte mit DevOps-Prinzipien umsetzen kann, in dem besser in einem, statt in vielen, Tools kollaboriert wird. Das ist gut, richtig und wichtig.&lt;/p&gt;
&lt;p&gt;Wichtige Voraussetzung ist allerdings, dass man erst die Arbeitskultur anpasst und dann die Prozesse anpasst, gefolgt vom Tooling. Im DevOps-Kontext spricht man nicht umsonst von „&lt;a href=&#34;http://dev2ops.org/2010/02/people-over-process-over-tools/&#34;&gt;People over Processes over Tools&lt;/a&gt;“. Die besten Tools helfen nicht, wenn die Prozesse beschissen sind. Die Prozesse helfen nicht, wenn die Kolleginnen und Kollegen mit den verschiedenen Rollen (Development, Operations, Security, QA, …) gegeneinander statt miteinander arbeiten.&lt;/p&gt;
&lt;p&gt;Mit diesem Buch möchte ich aufklären, wie es „richtig“ geht. Das beste, tollste, schnellste und effizienteste Auto bringt schließlich auch nicht, wenn man keine Straßen hat … und einen Führerschein auch nicht.&lt;/p&gt;
&lt;p&gt;Fachlich war die Motivation also klar: Wenn es um DevOps geht, gibt es großen Nachholbedarf, das sehe ich schließlich bei den ganzen Gesprächen. Ein „echtes“ deutsches Buch zu DevOps gab es auch nicht, sondern nur zwei Übersetzungen aus dem Englischen. Und so reifte die Idee für das zweite Buch.&lt;/p&gt;
&lt;h3 id=&#34;nicht-fachliche-motivation&#34;&gt;Nicht fachliche Motivation&lt;/h3&gt;
&lt;p&gt;Auf der nicht fachlichen Ebene sah es noch ein wenig anders aus. Hier kommen gleich mehrere Faktoren ins Spiel. Zunächst einmal war das Git-Buch recht technisch. Obwohl ich die Arbeit an dem Buch schon ziemlich herausfordernd fand, gab es hier meist nur eine technische Lösung, was das Schreiben deutlich vereinfacht hat. Bei DevOps ist das Ganze anders. Hier geht es viel um „weiche“ Themen, wie Menschen miteinander arbeiten. Das ist um ein Vielfaches herausfordernder. Das hat mich auch angespornt.&lt;/p&gt;
&lt;p&gt;Weiterhin wollte ich dieses Mal bei einem größeren Verlag veröffentlichen. Die Zusammenarbeit mit dem &lt;a href=&#34;https://mitp.de&#34;&gt;mitp-Verlag&lt;/a&gt; war zwar gut und ich soweit zufrieden, aber im Marketing und bei Verkaufszahlen merkt man dann schon einige Unterschiede. Der Einstieg beim größten deutschen IT-Verlag, dem &lt;a href=&#34;https://www.rheinwerk-verlag.de/&#34;&gt;Rheinwerk-Verlag&lt;/a&gt;, hat mit diesem Buch dann auch funktioniert.&lt;/p&gt;
&lt;p&gt;Die damalige Motivation für einen „besseren“ Job hatte ich beim DevOps-Buch hingegen nicht. Finanzielles spielte demnach weder primär noch sekundär eine Rolle. Ich bin trotzdem gespannt, welche neue Türe sich hierdurch gegebenenfalls öffnen.&lt;/p&gt;
&lt;p&gt;Meine grundlegende Motivation liest sich bis hierhin eigentlich gut, aber die Motivation muss schließlich nicht nur beim Start vorhanden sein, sondern auch während man das Buch schreibt …&lt;/p&gt;
&lt;h2 id=&#34;der-fortschritt-&#34;&gt;Der Fortschritt …&lt;/h2&gt;
&lt;p&gt;Die Motivation kontinuierlich und mit (höchster) Disziplin am Buch zu arbeiten, klang zu Beginn viel einfacher als es am Ende dann war. Um es kurz zu sagen: Es war ein Kampf. Und das war überhaupt nicht geil.&lt;/p&gt;
&lt;h3 id=&#34;der-unterschied-zu-damals&#34;&gt;Der Unterschied zu damals™&lt;/h3&gt;
&lt;p&gt;Im Vergleich zum Git-Buch hatte ich ein Aspekt komplett vernachlässigt. Mein Job damals war deutlich weniger anstrengend. Damals war ich rein in der Technik und ohne Reisetätigkeiten. Das lässt sich viel einfacher steuern, als mein jetziger Job. Bei GitLab hatte und habe ich jeden Tag etliche Videocalls mit Kunden. Bei diesen Calls muss ich stets fokussiert und effizient sein, was für den Kopf &lt;em&gt;deutlich&lt;/em&gt; anstrengender ist. Zudem machte mir der Job auch noch deutlich mehr Spaß, ich hatte auch noch (ab Mai 2022) etliche Dienstreisen, die einen regelten Tagesablauf nicht ermöglicht haben. Am Ende des Arbeitstages und auch am Wochenende war so nicht mehr so viel Gehirnkapazität übrig, um stetigen Fortschritt zu gewährleisten.&lt;/p&gt;
&lt;p&gt;Das „weiche“ Thema führte auch dazu, dass ich immer wieder überlegen musste, wie ich diverse Themen angehen sollte, damit man daraus auch etwas Sinnvolles herausziehen kann. Das führte immer wieder zu Verzögerungen, da ich dann noch die Gedanken schweifen lassen oder mit der ein oder der anderen Person aus dem Arbeitsumfeld besprechen musste, um mir neue Eindrücke abzuholen. Gleichzeitig hing die Frist immer im Nacken …&lt;/p&gt;
&lt;h3 id=&#34;produktivitätstechniken&#34;&gt;Produktivitätstechniken&lt;/h3&gt;
&lt;p&gt;Während des Schreibens probierte ich auch immer wieder ein paar Produktivitätstechniken aus. Je nach Phase des Buches war das auch relativ gut und hilfreich.&lt;/p&gt;
&lt;p&gt;Zu Beginn, nachdem die Grobstruktur gestanden hatte, fokussierte ich mich zunächst um Stichpunkte. Ich tippte also, was mir in den Kopf kam zu den einzelnen Themen in Stichpunkten herunter, und kümmerte mich kaum um die Grammatik. Das war wichtig, um überhaupt mal die Gedanken strukturieren zu können. Dabei fielen mir noch etliche Themen ein, die ich vorher gar nicht betrachtet hatte … die dann zu neuen Kapiteln führten.&lt;/p&gt;
&lt;p&gt;Ich setzte hierfür auf die &lt;a href=&#34;https://de.wikipedia.org/wiki/Pomodoro-Technik&#34;&gt;Pomodoro-Technik&lt;/a&gt;: Ich versuchte jeden Tag mindestens 25min, ohne Ablenkungen, Stichpunkte herunterzuschreiben, gefolgt von einer 5min Pause. Danach habe ich weiter gemacht … oder häufig auch nicht. Das war auch völlig in Ordnung.&lt;/p&gt;
&lt;p&gt;Das Ganze funktionierte so lange, bis es nicht mehr funktionierte. Irgendwann hatte ich dann alles notiert und es ging mehr Zeit drauf, zu überlegen, was man noch vergessen hat. Gerade für diese Phase benötigte ich viel Ruhe und Zeit, die durch Real-Life und Vollzeitjob nicht sonderlich gegeben war.&lt;/p&gt;
&lt;p&gt;Es gab also immer wieder Phasen – teilweise einige Monate – wo ich wenig bis gar nicht am Buch gearbeitet habe. Dabei war das offene Großprojekt, das Wissen, noch etwas erledigen zu müssen, die Frist und was sonst noch dazu gehört, stets im Hinterkopf. Schön war das zugegeben nicht wirklich.&lt;/p&gt;
&lt;p&gt;Später, beim Ausformulieren der Stichpunkte, habe ich mir hingegen ein Output-Ziel gesetzt. An Arbeitstagen wollte ich für zwei zusätzliche Seiten sorgen, an arbeitsfreien Tagen hingegen fünf. Da dann primär viel ausformuliert werden musste, klappte das für eine Weile auch einigermaßen gut.&lt;/p&gt;
&lt;h3 id=&#34;öffentlicher-statusbericht&#34;&gt;Öffentlicher Statusbericht&lt;/h3&gt;
&lt;p&gt;Gleichzeitig habe ich meinen eigenen Podcast &lt;a href=&#34;https://tilpod.net/&#34;&gt;TILpod&lt;/a&gt;, den ich mit Dirk Deimeke betreibe, vorangetrieben. Dort erzählte ich in jeder Folge, wie der Fortschritt am Buch ist. Treue Hörer und Hörerinnen haben also stets mitbekommen, wie ich vorankomme … oder auch nicht.&lt;/p&gt;
&lt;p&gt;Das öffentliche Dokumentieren des Fortschritts hat hingegen nicht zu mehr Druck geführt, zumindest nicht bewusst. Einige lustige Gegebenheiten haben sich hingegen schon dadurch ergeben. Vergangenes Jahr war ich dienstlich bei der KubeCon in Amsterdam, wo ich Standdienst bei GitLab gemacht habe. Es kamen erstaunlich viele mir unbekannte Personen auf mich zu und fragten, ob mein Buch denn nun fertig ist. Auch eine spannende Form, auf Hörer vom Podcast zu treffen.&lt;/p&gt;
&lt;p&gt;Ursprünglich war mein Plan, bis Ende 2022 fertig zu werden. Dass das nicht zu halten war, war mir schon zu Beginn klar. Unterschrieben habe ich den Autorenvertrag übrigens im Januar 2022. Erst im Sommer 2023, nachdem ich mehrfach die Fertigstellung nach hinten schieben musste, war der erste Entwurf fertig. Und dann ging erst die Arbeit mit diversen Korrekturläufen, dann zusammen mit meinem Lektor, los.&lt;/p&gt;
&lt;p&gt;Mein Ziel es dann noch im Jahr 2023 fertigzustellen hat dann nicht auch nicht mehr geklappt. Nachdem ich selbst für so viel Verspätung gesorgt hatte, lag es dann auch noch eine Weile bei meinem Lektor auf Halde: Mein Buch ist schließlich nicht das Einzige, meins musste entsprechend warten.&lt;/p&gt;
&lt;p&gt;Der Spätsommer und Herbst war dann ebenfalls ziemlich frustrierend. Jeden Monat verschob sich die Fertigstellung um einen Monat. Jedes Mal, wenn ich dachte, dass ich jetzt wirklich mal fertig wurde, mussten wir es abermals um einen Monat verschieben. Insgesamt lagen zwischen der Unterzeichnung des Autorenvertrags und der Fertigstellung ziemlich genau zwei Jahre.&lt;/p&gt;
&lt;h3 id=&#34;keine-hilfsmittel&#34;&gt;(Keine) Hilfsmittel&lt;/h3&gt;
&lt;p&gt;Ganz unabhängig von der Motivation und der Produktivität finde ich es auch noch spannend auf mögliche Hilfsmittel zu werfen. Insbesondere ChatGPT, LanguageTool und Obsidian.&lt;/p&gt;
&lt;h4 id=&#34;chatgpt&#34;&gt;ChatGPT&lt;/h4&gt;
&lt;p&gt;Während des Schreibens des Buches ploppte dann auch noch ChatGPT auf und der AI-Hype ging so richtig los. An vielen Stellen las ich dann, dass man ja jetzt „ganz einfach“ Texte schreiben lassen kann und bald nur noch AI-generierte Bücher gibt.&lt;/p&gt;
&lt;p&gt;Ich dachte dann: Ja gut, ich habe hier ja ein Beispiel, schauen wir mal, ob ChatGPT hier überhaupt realistisch helfen kann. Tja, nun … tat es nicht wirklich.&lt;/p&gt;
&lt;p&gt;Ich hatte natürlich nicht vor, mein Buch per ChatGPT schreiben zu lassen. Das funktioniert ohnehin nicht. Die Frage, die ich mir stattdessen stellte, ging mehr in die Richtung: Wie kann mir ggf. ChatGPT helfen?&lt;/p&gt;
&lt;p&gt;Typische Prompts à la „Schreib mir etwas zu $THEMA im Rahmen von DevOps“ produzierten (natürlich) sehr, sehr oberflächliche Texte, die sich zu 95 % ohnehin immer nur wiederholten. Praktisch war hingegen, ChatGPT zu nutzen, um zu prüfen, ob man etwas vergessen hatte. So ergänzte ich zur „normalen“ Recherche auch ChatGPT, wobei der tatsächliche Nutzen eher gering war, schließlich stand der Großteil und ChatGPT kann man ja bekanntlich auch nicht alles glauben. Häufig kam da auch nur Mist raus.&lt;/p&gt;
&lt;h4 id=&#34;languagetool&#34;&gt;LanguageTool&lt;/h4&gt;
&lt;p&gt;ChatGPT war also nur wenig hilfreich, anders sah es bei &lt;a href=&#34;https://languagetool.org/&#34;&gt;LanguageTool&lt;/a&gt; aus, was für sprachliche Korrekturen sehr hilfreich war. Dafür setzte ich auf die Premium-Variante für knapp 60 € pro Jahr.&lt;/p&gt;
&lt;p&gt;LanguageTool gab mir &lt;em&gt;einige&lt;/em&gt; Hinweise für die korrekte Nutzung der deutschen Sprache. Viel zu lange Sätze, Wortwiederholungen, Kommasetzung und noch etliche weitere Hinweise wurden mir dann regelmäßig angezeigt, sodass ich da noch einmal drauf geschaut habe.&lt;/p&gt;
&lt;p&gt;Praktisch war zudem das Feature „Sentence rephrasing by A.I.“. Hier konnte man einzelne Sätze aus einigen Paragrafen neu formulieren lassen. Das half mir insbesondere dann, wenn ich an einigen komplexen Sätzen viel zu lange hing, weil diese kaum verständlich waren.&lt;/p&gt;
&lt;h4 id=&#34;obsidian&#34;&gt;Obsidian&lt;/h4&gt;
&lt;p&gt;DIe meiste Zeit beim Schreiben verbrachte ich im Tool &lt;a href=&#34;https://obsidian.md/&#34;&gt;Obsidian&lt;/a&gt;. Das ist eigentlich mehr als persönliches Knowledge-Base gedacht. Für mich half es hingegen das Buch primär in Markdown herunter zu schreiben, da es mich nicht zu sehr abgelenkt hat. Viele der Features von Obsidian habe ich allerdings nicht verwendet. Einige fehlerhafte Verlinkungen fielen mir dann nur regelmäßig auf. LanguageTool ließ sich zudem als Plug-in einbinden und nutzen.&lt;/p&gt;
&lt;p&gt;Zum Ende hin musste ich allerdings sowieso auf Microsoft Word switchen, weil das der Workflow vom Verlag so vorgibt. Bis dahin konnte man es wenigstens gut in Git-Repositorys tracken, sodass ich Anpassungen von Reviewern und Lektor einfach nachvollziehen konnte.&lt;/p&gt;
&lt;h2 id=&#34;fazit&#34;&gt;Fazit&lt;/h2&gt;
&lt;p&gt;Warum sollte man also eher kein Fachbuch schreiben?&lt;/p&gt;
&lt;p&gt;Es ist verdammt anstrengend, es geht richtig viel Zeit drauf und ist häufig auch echt frustrierend. Reich wird man nicht. Ob es sich für mich gelohnt hat, wird sich zeigen. In den letzten zwei Jahren verbrachte ich also sehr viel Zeit mit meinem Vollzeitjob und dem Schreiben des Buches. Viel Zeit drum herum, blieb da nicht. Gesund war das ganze auch nicht sonderlich.&lt;/p&gt;
&lt;h2 id=&#34;das-fertige-buch&#34;&gt;Das fertige Buch&lt;/h2&gt;
&lt;p&gt;Wer bis hierhin gelesen hat, wird gemerkt haben, dass das Thema des Buches eine untergeordnete Rolle gespielt hat, dazu folgt noch ein weiterer Artikel. Das DevOps-Buch gibt es überall da, wo es Bücher gibt – insbesondere &lt;a href=&#34;https://www.rheinwerk-verlag.de/devops/&#34;&gt;direkt beim Verlag&lt;/a&gt;. Es erscheint am 5. März 2024. Ich warte zurzeit noch auf meine Belegexemplare und kann es kaum erwarten.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Tooltipp: Diagramme mit Mermaid</title>
      <link>https://svij.org/blog/2023/05/20/tooltipp-diagramme-mit-mermaid/</link>
      <pubDate>Sat, 20 May 2023 03:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2023/05/20/tooltipp-diagramme-mit-mermaid/</guid>
      <description>&lt;p&gt;Es gibt ja viele verschiedene Tools, mit denen man Diagramme erstellen kann.
Zuletzt setzte ich vor allem auf &lt;a href=&#34;https://www.drawio.com/&#34;&gt;draw.io&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Praktisch an drawio finde ich, dass das grafische Tool recht einfach zu bedienen ist
und damit beziehe ich mich vor allem darauf, wie gut die gleichen Abstände zwischen
den Elementen eines Diagramms abbildbar sind.&lt;/p&gt;
&lt;p&gt;Viel lieber hätte ich allerdings ein Tool, womit ich die Diagramme als Code definieren
kann. Hierzu bin ich neulich auf &lt;a href=&#34;https://mermaid.js.org/&#34;&gt;mermaid.js&lt;/a&gt; gestoßen.&lt;/p&gt;
&lt;p&gt;Mermaid.js hat diverse Diagrammtypen, die verwendet werden können. Darunter Flowcharts,
Gantt Charts oder Pie Chart. Persönlich finde ich Git Graph nützlich, Mindmaps,
sowie Timeline. Die ganze Liste findet sich in der &lt;a href=&#34;https://mermaid.js.org/intro/&#34;&gt;Dokumentation&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Besonders praktisch ist es vor allem, wenn man sich die &lt;a href=&#34;https://mermaid.js.org/ecosystem/integrations.html#productivity&#34;&gt;Integrationen&lt;/a&gt; anschaut
und genau dabei bin ich auch auf Mermaid gestoßen: Durch die Ablage der Dateien
in GitLab oder auch GitHub, wird es direkt im Browser angezeigt. Das beinhaltet
auch die Nutzung und Darstellung in Issues.&lt;/p&gt;
&lt;p&gt;Beispiel-Code für die Darstellung von GitLab Flow:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;%%{init: { &#39;logLevel&#39;: &#39;debug&#39;, &#39;theme&#39;: &#39;base&#39;, &#39;gitGraph&#39;: {&#39;showBranches&#39;: true, &#39;showCommitLabel&#39;:true,&#39;mainBranchName&#39;: &#39;production&#39;}} }%%
gitGraph
    commit
    commit
    branch main
    commit
    commit
    branch feature/foobar
    commit
    commit
    checkout main
    merge feature/foobar
    checkout production
    merge main
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Output:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;GitLab-Flow&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/gitlab-flow.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Damit man aber nicht mühselig die Dokumentation lesen muss, existiert auch noch
ein Editor im Browser unter &lt;a href=&#34;https://mermaid.live/&#34;&gt;mermaid.live&lt;/a&gt;. Dort kann man
dann auch viel einfacher die Diagramme erstellen und dort hin rüberkopieren, wo
man diese braucht.&lt;/p&gt;
&lt;p&gt;Vielleicht hilft es ja der ein oder anderen Person!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Chemnitzer Linux-Tage 2023: Es war mal wieder schön</title>
      <link>https://svij.org/blog/2023/04/16/chemnitzer-linux-tage-2023-es-war-mal-wieder-sch%C3%B6n/</link>
      <pubDate>Sun, 16 Apr 2023 22:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2023/04/16/chemnitzer-linux-tage-2023-es-war-mal-wieder-sch%C3%B6n/</guid>
      <description>&lt;p&gt;Vor nun etwas mehr als einem Monat fanden die Chemnitzer Linux-Tage statt.
Nachdem es die letzten drei Jahre aus bekannten Gründen ausgefallen ist, bzw.
rein virtuell stattgefunden hat, war ich auch mal wieder am Start.&lt;/p&gt;
&lt;p&gt;Spannend war für mich, wie wenig mich die Vorträge selbst interessieren: Ich
war tatsächlich nur bei meinen eigenen Vorträgen drin und habe die Zeit sonst
eigentlich nur damit verbracht, mit neuen und alten Bekannten nach etlichen Jahren
wieder zu quatschen.&lt;/p&gt;
&lt;h3 id=&#34;warum-devops-scheitert-&#34;&gt;Warum DevOps scheitert …&lt;/h3&gt;
&lt;p&gt;Fleißige Hörer des Podcasts &lt;a href=&#34;https://tilpod.net&#34;&gt;TILpod&lt;/a&gt; von &lt;a href=&#34;https://dirk.deimeke.ruhr/&#34;&gt;Dirk Deimeke&lt;/a&gt;
und mir, wissen bereits, dass ich an einem neuen Buch arbeite, nämlich wo es
um DevOps in allen Tiefen geht.&lt;/p&gt;
&lt;p&gt;In dem Zuge werde ich in Zukunft vermehrt sicherlich den ein oder anderen Vortrag
über DevOps halten. Dieses Mal lautete mein Vortragstitel &lt;a href=&#34;https://chemnitzer.linux-tage.de/2023/de/programm/beitrag/153&#34;&gt;„Warum DevOps scheitert …“&lt;/a&gt;
in dem ich erzählte, warum DevOps in der Regel in den verschiedenen Firmen
scheitert.&lt;/p&gt;
&lt;p&gt;Die Aufzeichnung des Vortrags findet sich &lt;a href=&#34;https://media.ccc.de/v/clt23-153-warum-devops-scheitert&#34;&gt;hier auf media.ccc.de&lt;/a&gt;.&lt;/p&gt;
&lt;iframe width=&#34;1024&#34; height=&#34;576&#34; src=&#34;https://media.ccc.de/v/clt23-153-warum-devops-scheitert/oembed&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
&lt;p&gt;Spannend war das Feedback, was ich dazu bekommen habe, da sehr sehr viele genau
dieselben Schmerzen im eigenen Unternehmen erlebt haben und sich fragen, was
sie tun können, um es in die richtige Richtung zu schubsen.&lt;/p&gt;
&lt;p&gt;Die Frage ist nicht ganz so einfach und schwierig pauschal zu sagen, da es eine
Arbeitskultur ist, die über einen längeren Zeitraum strategisch geplant und
umgesetzt werden muss. Und je nach Firmenkultur geht sowas schneller oder langsamer.&lt;/p&gt;
&lt;p&gt;Ich für mich hab durch das Feedback vor allem viel für mein Buchprojekt mitgenommen,
sodass ich dem Thema ein eigenes Kapitel gewidmet habe, was ursprünglich gar nicht
geplant war.&lt;/p&gt;
&lt;p&gt;Aber mehr gibt es dazu zu lesen, wenn das Buch dann fertig ist.&lt;/p&gt;
&lt;h3 id=&#34;warum-man-nicht-in-der-it-arbeiten-sollte-und-warum-wir-es-trotzdem-tun&#34;&gt;Warum man nicht in der IT arbeiten sollte (und warum wir es trotzdem tun)&lt;/h3&gt;
&lt;p&gt;&lt;a href=&#34;https://dirk.deimeke.ruhr/&#34;&gt;Dirk Deimeke&lt;/a&gt;, &lt;a href=&#34;https://www.my-it-brain.de/wordpress/&#34;&gt;Jörg Kastning&lt;/a&gt;
und ich kamen irgendwann und irgendwie auf die Idee einen Vortrag einzureichen
unter dem Titel &lt;a href=&#34;https://chemnitzer.linux-tage.de/2023/de/programm/beitrag/156&#34;&gt;„Warum man nicht in der IT arbeiten sollte und warum wir es trotzdem tun“&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Auch hiervon findet sich die Aufzeichnung des Vortrags &lt;a href=&#34;https://media.ccc.de/v/clt23-156-warum-man-nicht-in-der-it-arbeiten-sollte-und-warum-wir-es-trotzdem-tun&#34;&gt;auf media.ccc.de&lt;/a&gt;.&lt;/p&gt;
&lt;iframe width=&#34;1024&#34; height=&#34;576&#34; src=&#34;https://media.ccc.de/v/clt23-156-warum-man-nicht-in-der-it-arbeiten-sollte-und-warum-wir-es-trotzdem-tun/oembed&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
&lt;p&gt;Spannend war die Resonanz des Vortrags. Wir bekamen den größten Hörsaal der
mit seinen knapp 250 Plätzen voll belegt war und auch noch einige an den Seiten
standen und saßen. Auch die Videoaufzeichnung hat schon über 1000 Aufrufe.&lt;/p&gt;
&lt;p&gt;Auch das Feedback hinterher war durchaus positiv und das, obwohl wir da auch ein
wenig humoristisch unterwegs waren. Gerade auf solchen Veranstaltungen wird
vom Gefühl her, die IT immer wieder glorifiziert, aber selten wird mal geschaut,
was einem stört und was man dagegen ändern kann.&lt;/p&gt;
&lt;p&gt;Nicht zu selten sehe und spreche ich mit Leuten, die unzufrieden mit ihrem Job
in der IT sind, aber nach 15 oder mehr Jahren im selben Unternehmen sich noch
nicht mal umschauen, wie die Marktlage so ist.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Ich mag ja Community-Veranstaltungen für die Chemnitzer Linux-Tage. Mittlerweile
hat sich der Grund bei mir immer weiter verschoben, sodass ich wirklich nur noch
hingehe, um Leute zu treffen. Weiterhin möchte ich mit meinen eigenen Vorträgen
anderen Leuten wissen vermitteln und das entgegen kommende Feedback verarbeiten.&lt;/p&gt;
&lt;p&gt;In dem Sinne: Gerne wieder nächtes Jahr. Eine Idee für einen oder zwei Anschlussvorträge
habe ich auch schon im Hinterkopf.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>DevOps-Metriken: Nicht nur für das Management interessant</title>
      <link>https://svij.org/blog/2022/11/03/devops-metriken-nicht-nur-f%C3%BCr-das-management-interessant/</link>
      <pubDate>Thu, 03 Nov 2022 10:00:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2022/11/03/devops-metriken-nicht-nur-f%C3%BCr-das-management-interessant/</guid>
      <description>&lt;p&gt;In meiner Karriere arbeitete ich in verschiedenen Aufgabengebieten in
verschiedenen Firmen, teils intern, teils extern, teils in kleinen, teils in
größeren Firmen. Von Anfang an waren mir dabei zwei Dinge wichtig: Ich wollte
zum einen möglichst zügig meine Aufgaben erledigen, aber ich wollte zum anderen
auch, dass die Qualität stimmt. Letztendlich geht beides Hand in Hand: Wenn die
Qualität stimmt und alles ordentlich implementiert wurde, dann sind die
Aufgaben auch zügig erledigt. Wenn nicht, dann holten einem die fehlerhaften
Implementierungen schneller ein, als einem lieb war.&lt;/p&gt;
&lt;p&gt;Die Realität sah allerdings häufig so aus: Die verschiedenen Kollegen in den
verschiedenen Firmen haben sich häufig nur auf den ersten Punkt: Hauptsache die
Arbeit ist schnell erledigt. Das hieß konkret, dass jeder für sich die
Änderungen implementiert und direkt in das Repository gepusht hat, ohne dass
ein Code-Review stattgefunden hat. Auf den ersten Blick funktioniert es ja,
also ist alles kein Problem, schließlich wurde so ja schon seit 20 Jahren
gearbeitet.&lt;/p&gt;
&lt;p&gt;Die Probleme türmten sich häufig allerdings nachgelagert auf. Zu häufig wurde
Code mit geringer Qualität implementiert. Zu häufig führten die Änderungen zu
Problemen nach dem Ausrollen, weil viele Tests, wenn überhaupt, nur halbherzig
umgesetzt wurden. Für mich und die anderen Kollegen, denen gute Qualität auch
wichtig war, führte das dazu, dass man erst angefangen hat, die eigentlichen
Probleme zu umschiffen, bevor man dann versucht hat das Team und die
Teamleitung zu überzeugen, lieber einen Schritt langsamer zu machen, damit man
hinterher weniger Probleme hat. Der ersten und einfachsten Schritte, die wir
jeweils vorgeschlagen haben, waren die Einführung von Code-Review, sowie
durchgängiges automatisiertes Testen aller Änderungen, bevor diese die den
Hauptentwicklungsbranch gemergt werden. Erst im zweiten Schritt ging es dann an
das kontinuierliche Ausrollen der Software.&lt;/p&gt;
&lt;p&gt;Die erste Herausforderung war es also, sowohl das Team, als auch die
Teamleitung und ggf. auch weitere Führungskräfte zu überzeugen, hier einen
Schritt langsamer zu gehen, um dafür mittel- und langfristig weniger Probleme
zu haben, um somit produktiver zu sein. Die angeführten Ideen führten bloß
selten auf Anhieb auf Begeisterung. Gängige Argumente waren dann eher dieser
Natur:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;„Das haben wir doch schon immer so gemacht.“&lt;/li&gt;
&lt;li&gt;„Wir haben so viel zu tun, wir haben keine Zeit für Code-Review.“&lt;/li&gt;
&lt;li&gt;„Dieser Mehraufwand kommt doch gar nicht beim Kunden an.“&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Teilweise konnte man die Bedenken ja auch gut nachvollziehen, schließlich lief
das Business ja schon ein bis zwei Jahrzehnte. Stellenweise konnten die
Bedenken zumindest für das einzelne Team ausgeräumt werden. Mal halfen einfache
Argumente, mal wurde eine Testphase gestartet. Zu Problemen kam es dann bei
diesen Testphasen allerdings auch, denn nicht selten blieben Reviews liegen
oder wurden einfach blind durchgewunken, sodass sich scheinbar nur Nachteile
gebildet haben.&lt;/p&gt;
&lt;p&gt;Gerade diese Woche hatte ich eine Diskussion mit einem Software-Engineer eines
Kunden, der ebenfalls der Meinung war, dass Code-Reviews nicht gebraucht wird,
schließlich arbeiten sie ja schon immer so und es ist “gut”. Auf die Frage,
was denn “gut” heißt, hieß es nur: “Wir releasen alle zwei Wochen!”. Eine
nachvollziehbare Metrik ist das hingegen nicht, schließlich kann alle zwei
Wochen Code mit schlechter Qualität ausgeliefert werden, der zudem sehr
ineffizient entwickelt wurde.&lt;/p&gt;
&lt;p&gt;Was also in der Praxis gefehlt hat, sind Fakten. So stellte man sich häufig die
Fragen: Hat es sich verbessert oder verschlechtert? Wie sehr hat es sich
verbessert oder verschlechtert? Was genau ist denn nun besser oder eben
schlechter?&lt;/p&gt;
&lt;p&gt;Die Bewertung erfolgte letztendlich häufig aus einem Bauchgefühl heraus und
weniger nach klaren Fakten. Und genau hier haben damals, wie teilweise auch
heute, Tatsachen gefehlt. Für diese Fakten gibt es einige Metriken, wodurch man
als Team besser entscheiden kann, wo es etwas zu verbessern gibt und wo
vielleicht einige Experimente nicht von Erfolg gekrönt waren.&lt;/p&gt;
&lt;h3 id=&#34;die-dora-metriken&#34;&gt;Die DORA-Metriken&lt;/h3&gt;
&lt;p&gt;Damals, als ich vor den zuvor erläuterten argumentativen Problemen stand, war
DevOps als Kultur noch kein bekanntes Thema. Viele kulturelle Aspekte von
DevOps waren allerdings schon vor der Entstehung des Begriffs schon relevant.
Was allerdings aus dem DevOps-Movement entstanden ist und mir damals für die
Argumentation geholfen hätte, sind die &lt;a href=&#34;https://www.devops-research.com&#34;&gt;DORA&lt;/a&gt;-Metriken.&lt;/p&gt;
&lt;p&gt;Die DORA-Metriken sind vier Metriken, womit sich der Erfolg von DevOps messen
lassen. Entwickelt und benannt sind sie von der “DevOps Research and
Assessment”. Folgende vier Metriken gibt es:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Deployment Frequency&lt;/li&gt;
&lt;li&gt;Lead Time&lt;/li&gt;
&lt;li&gt;Change Failure Rate&lt;/li&gt;
&lt;li&gt;Time to Restore Service&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Diese Metriken werden vor allem vom Management herangezogen, um zu schauen, wie
gut die DevOps-Prozesse denn in dem Unternehmen funktionieren. Es lohnt sich
allerdings, diese Metriken auch mal aus einem anderen Blickwinkel anzuschauen,
der häufig vergessen wird, nämlich der Entwicklerproduktivität.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Deployment Frequency&lt;/strong&gt;: Diese Metrik gibt an, wie oft ein Deployment stattfindet.
Hier gilt grundsätzlich: Je häufiger, desto besser, denn so landen die
Änderungen, die implementiert wurden, schnell bei den Endbenutzern. Für die
Entwickler heißt es letztendlich, dass diese langsam daran hingeführt werden
müssen, damit sie das Vertrauen in das eigene Projekt aufbauen können, um
häufig deployen zu können. Und um das umzusetzen, müssen weitere Methoden und
Prozesse eingeführt werden, um das Vertrauen eben zu stärken. Genau hier
spielen Punkte wie Code-Review hinein. Diese Metrik komplett alleine sagt
allerdings noch nicht viel aus.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Lead Time&lt;/strong&gt;: Zu Beginn dieses Artikels ging es ja um das zügige Abschließen
der zugewiesenen Arbeit. Das ist auch ein Teil, der für die Lead Time relevant
ist. Diese gibt an, wie lange es dauert, bis ein Commit, der erstellt wurde,
auf die Produktivumgebung ausgerollt wurde. Dies geht also auch Hand in Hand
mit der Deployment Frequency daher.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Change Failure Rate&lt;/strong&gt;: Bisher unbeachtet waren bei den ersten beiden Metriken
war, was passiert, wenn Fehler auftreten. Eine hohe Deployment Frequency und
eine schnelle Lead Time ist schön und gut, allerdings bringt das alles nicht so
viel, wenn viele Fehler auftreten. Genau dafür steht die dritte Metrik da, die
Change Failure Rate, bei der gemessen wird, wie hoch die Fehlerhäufigkeit nach
Deployments ist.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Time to Restore Service&lt;/strong&gt;: Falls nun Fehler auftreten, sollte diese möglichst
zügig korrigiert werden. Mit der Time to Restore Service Metrik wird daher
angegeben, wie lange es dauert, bis der Dienst bei einem Fehler wieder zur
Verfügung steht.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Für die einen oder anderen dürften die DORA-Metriken nichts Neues sein.
Allerdings wird es meiner Einschätzung nach häufig eben nur mit dem Blick des
Managements für die Endnutzer draufgeschaut und weniger aus dem Blick des Teams
und deren Produktivität. Dabei lassen sich gerade diese Metriken auch dafür
wunderbar nutzen, etwa um Entscheidungen im Entwicklungsprozess zu begutachten,
ob es nun etwas besser oder schlechter gemacht hat. Dabei ist wichtig, dass man
nicht nur diese Metriken kennt, sondern diese auch Tool-unterstützt einfach
herauslesen kann. Anschließend kann es nicht nur für die DevOps-Produktivität
verwendet werden, sondern auch als Vehikel für Entwicklungsprozesse verwendet
werden.&lt;/p&gt;
&lt;p&gt;Mein Appell lautet daher: Einfach mal überlegen und schauen, wie der
Entwicklungsprozess verschlankt und effizienter gemacht werden kann, damit
nicht nur die Effizienz der Personen gesteigert wird, sondern auch deren
Zufriedenheit. Denn das Wichtigste ist am Ende ja, dass die
Software-Entwicklungsteams genau das tun, wofür sie angestellt wurden: Software
entwickeln, ohne zu viele Steine in den Weg gelegt zu bekommen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Kein Freund von Online-Zertifizierungsprüfungen</title>
      <link>https://svij.org/blog/2022/10/24/kein-freund-von-online-zertifizierungspr%C3%BCfungen/</link>
      <pubDate>Mon, 24 Oct 2022 20:00:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2022/10/24/kein-freund-von-online-zertifizierungspr%C3%BCfungen/</guid>
      <description>&lt;p&gt;Die Cloud Native Computing Foundation (CNCF) zusammen mit der Linux Foundation
bieten drei verschiedene Zertifizierungen rund um Kubernetes an:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://www.cncf.io/certification/ckad/&#34;&gt;Certified Kubernetes Application Developer (CKAD)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.cncf.io/certification/cka/&#34;&gt;Certified Kubernetes Administrator (CKA)&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.cncf.io/certification/cks/&#34;&gt;Certified Kubernetes Security Specialiast (CKS)&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Im letzten Jahr hatte ich die CKAD-Prüfung abgelegt. Darüber schrieb ich bereits
in einem separaten &lt;a href=&#34;https://svij.org/blog/2021/12/12/certified-kubernetes-application-developer-pr%C3%BCfungsvorbereitung-und-absolvierung/&#34;&gt;Blogpost&lt;/a&gt;, wo ich genauer darauf einging, wozu man eigentlich eine Zertifizierung
braucht, wie meine Prüfungsvorbereitung aussah und wie die Prüfung selbst ablief.&lt;/p&gt;
&lt;p&gt;In diesem Blogpost konzentriere ich mich nur auf den letzten Teil: Die Prüfung
selbst. Vor allem auf die &amp;ldquo;Zulassung&amp;rdquo; zur Prüfung. Im letzten Blogpost habe ich
mich schon beklagt, dass es 30 Minuten gedauert hat, bis man die Prüfung starten
durfte. Denn es musste ja aufwändig über eine Person im Chat über die Webcam
geprüft werden, ob man denn auch einen sauberen, leeren Tisch hat, keinerlei
Dokumente an der Wand und keine anderen Dinge am Körper hat, um schummeln zu können.&lt;/p&gt;
&lt;p&gt;Letztes Mal war ich schon schwer genervt von der Prüfung vor der Prüfung, da das
ganze 30 Minuten gedauert hat und die Person dahinter wenig verständlich war und
es eben super lange gedauert hat. Dieses Mal war ich gespannt, ob es besser wurde
oder eben nicht.&lt;/p&gt;
&lt;p&gt;Und was soll ich sagen: Es wurde gravierend schlechter! Ich wäre ja froh gewesen,
wenn es nur 30 Minuten gedauert hätte. Tatsächlich hatte ich zwei Versuche an
einem Tag, bereits im September. Zum ausgewählten Termin wählte ich mich ein und
beim Zeigen der Wände über die Webcam, hatte ich einen Disconnect, sodass die
Person dahinter nicht weiter prüfen konnte. Das passierte am selben Tag gleich
noch ein Mal. Super! Nicht. Die Prüfung konnte ich dann nicht ablegen, weil ich mich
nicht mehr einwählen konnte.&lt;/p&gt;
&lt;p&gt;Der zweite Versuch war dann also gestern. Die Verifizierung war auch hier wieder
super ätzend und dauerte 50 Minuten, bis mir geschrieben wurde, dass die Prüfung
nun beginnt. Drei Minuten später folgte allerdings die neue Nachricht: Sorry, du hattest
wohl einen Reconnect. Der Check muss nun wiederholt werden …&lt;/p&gt;
&lt;p&gt;Nun, also nochmal einen Check gemacht. Dauerte dann immerhin nur 20 Minuten.
Insgesamt dauerte es also 1:10h, bis ich die Prüfung starten konnte.&lt;/p&gt;
&lt;p&gt;Die Prüfung empfand ich deutlich einfacher als die CKAD Prüfung. Bedingung hier
war für mich in meinem Fall aber auch, dass man Praxiserfahrung hat, sodass ich
das meiste gar nicht neu lernen musste, sondern direkt anwenden konnte. Üben
sollte man allerdings auf jeden Fall.&lt;/p&gt;
&lt;p&gt;Auch weiterhin gefällt mir die praktische Prüfung sehr: So wird sichergestellt,
dass man das ganze, was man können muss, auch anwenden kann. Das ist
bei Multiple-Choice-Aufgaben eher nicht der Fall. Obwohl mir jetzt nur noch eine
der drei Zertifizierungen fehlt, werde ich die letzte wohl nicht erneut machen.
Mit dieser mühseligen Art seinen Arbeitsplatz für die Prüfung checken zu lassen,
werde ich wohl eher keine weitere Prüfung mehr in so einer Art machen. Dann lieber
über ein Schulungszentrum, wo man solche Prüfungen ablegen kann. Blöd nur, dass
es das für die Kubernetes-Zertifizierungen so etwas meines Wissens nach gar nicht gibt.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Bessere Git Diffs im Terminal mit delta</title>
      <link>https://svij.org/blog/2022/01/23/bessere-git-diffs-im-terminal-mit-delta/</link>
      <pubDate>Sun, 23 Jan 2022 21:10:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2022/01/23/bessere-git-diffs-im-terminal-mit-delta/</guid>
      <description>&lt;p&gt;Vor über vier Jahren schrieb ich einen Blogpost über &lt;a href=&#34;https://svij.org/blog/2018/01/12/schonere-git-diffs-im-terminal-mit-diff-so-fancy/&#34;&gt;„Schönere Git Diffs im Terminal mit diff-so-fancy“&lt;/a&gt;.
Mit &lt;a href=&#34;https://github.com/so-fancy/diff-so-fancy&#34;&gt;diff-so-fancy&lt;/a&gt; ist es möglich
schönere bzw. bessere Diffs mit Git anzeigen zu lassen. Als Vergleich
dient hier natürlich das klassische &lt;code&gt;diff&lt;/code&gt; Kommandozeilentool, was vom System
mitgeliefert wird und nur sehr wenig optisch die Unterschiede zwischen zwei
Versionen hervorhebt.&lt;/p&gt;
&lt;p&gt;Kürzlich bin ich auf &lt;a href=&#34;https://github.com/dandavison/delta&#34;&gt;delta&lt;/a&gt; gestoßen, was
noch einmal deutlich besser als diff-so-fancy ist und zwar für mich vor allem
für die bessere farbliche Hervorhebung und für die Nutzung von Syntaxhervorhebung,
die abhängig der verwendeten Programmiersprache ist. Darüber hinaus gibt es auch
noch Zeilennummerierungen und ein optionales Side-by-Side View.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Ein git diff mit delta&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/delta-diff.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Ich kann jeder Person, die &lt;code&gt;git diff&lt;/code&gt; auf der Kommandozeile ausführt, nur empfehlen
mal ein Blick darauf zu werfen. &lt;a href=&#34;https://dandavison.github.io/delta/introduction.html&#34;&gt;Die Dokumentation&lt;/a&gt;
und das &lt;a href=&#34;https://github.com/dandavison/delta&#34;&gt;GitHub-Repository&lt;/a&gt; listen alle
Funktionen auf, zeigen mehr Screenshots und listet auf, wie man es installiert.
Unter den gängigen Linux-Distributionen, Windows und macOS ist das Tool unter
&lt;code&gt;delta&lt;/code&gt; bzw. &lt;code&gt;git-delta&lt;/code&gt; in den Paketquellen enthalten. Einzig in Ubuntu und Debian
muss man sich das Debian-Paket händisch installieren. Mehr dazu in der Dokumentation
zur &lt;a href=&#34;https://dandavison.github.io/delta/installation.html&#34;&gt;Installation&lt;/a&gt; und
&lt;a href=&#34;https://dandavison.github.io/delta/configuration.html&#34;&gt;Konfiguration&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Certified Kubernetes Application Developer: Prüfungsvorbereitung und Absolvierung</title>
      <link>https://svij.org/blog/2021/12/12/certified-kubernetes-application-developer-pr%C3%BCfungsvorbereitung-und-absolvierung/</link>
      <pubDate>Sun, 12 Dec 2021 18:00:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/12/12/certified-kubernetes-application-developer-pr%C3%BCfungsvorbereitung-und-absolvierung/</guid>
      <description>&lt;p&gt;Wer meinen Blog ein wenig liest und mich ein wenig kennt, weiß, dass ich aktuell
relativ viel mit Kubernetes „herumspiele“. Siehe meinen Blogpost zum &lt;a href=&#34;https://svij.org/blog/2021/11/28/homeserver-setup-2021-k3s-mit-flux-und-helm/&#34;&gt;Homeserver-Setup
in 2021&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Dieser Blogpost geht ein wenig darauf ein, warum ich die Zertifizierung
„Certified Kubernetes Application Developer“ (CKAD) gemacht habe, wie ich mich
darauf vorbereitet habe und warum das Drumherum um die Prüfung total nervig
war.&lt;/p&gt;
&lt;p&gt;Die CKAD-Zertifizierung ist die Zertifizierung, die sich eher an Entwickler
richtet, während die „Certified Kubernetes Administrator“ Zertifizierung (CKA,
ohne D) und „Certified Kubernetes Security Specialist“ Zertifizierung (CKS)
sich eher an Administratoren richtet.&lt;/p&gt;
&lt;p&gt;Der Spaß kostet mittlerweile $375 und findet Online statt. Es gibt immer allerdings
immer wieder Angebote, wo es weniger kostet.&lt;/p&gt;
&lt;h1 id=&#34;warum-eigentlich-eine-zertifizierung&#34;&gt;Warum eigentlich eine Zertifizierung?&lt;/h1&gt;
&lt;p&gt;Die allgemeine Frage, warum man eine Zertifizierung braucht und auch für wen
sich eine Zertifizierung lohnt, ist immer so eine Frage. So einfach lässt sich
das nicht beantworten, da dort viele Faktoren reinspielen. Es gibt einige
(vor allem junge) Leute, die mehrere Zertifizierungen „sammeln“ ohne
je praktische Erfahrung gesammelt zu haben. Sieht zwar schön aus, hat nur keinen
wirklichen Mehrwert. Die Praxis ist wichtig! Andersrum gilt das gleiche:
Wer tagtäglich über mehrere Jahre mit Tools arbeitet, für die es
Zertifizierungen gibt, braucht es vermutlich auch eher nicht.&lt;/p&gt;
&lt;p&gt;Ich, für meinen Teil, hatte verschiedene Gründe, weshalb ich mich ran gewagt habe:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Ich wollte neben meiner praktischen Erfahrung für den Heimgebrauch wissen,
was mir grundsätzlich noch fehlt.&lt;/li&gt;
&lt;li&gt;Ich muss generell für meinen Job wissen, wie Kubernetes grundsätzlich
funktioniert und wie DevOps-Teams ihre Anwendungen in den Cluster bekommen.&lt;/li&gt;
&lt;li&gt;Ich hab nach Absolvierung meines Studiums vor ein paar Jahren
Prüfungssituationen vermisst. (Wer hier Ironie findet, darf sie gern
behalten.)&lt;/li&gt;
&lt;li&gt;Es ist generell bei uns auf der Arbeit gewünscht, sich fortzubilden, die
Kosten des Kurses wurden auch übernommen.&lt;/li&gt;
&lt;/ul&gt;
&lt;h1 id=&#34;prüfungsvorbereitung&#34;&gt;Prüfungsvorbereitung&lt;/h1&gt;
&lt;p&gt;Am wenigsten Zeitaufwand für die Vorbereitung auf die Prüfung hat man, wenn man
gute Erfahrung in Kubernetes hat. Welch Überraschung. Konkret geht es allerdings
in der Prüfung ja darum, vor allem Anwendungen auf ein Kubernetes-Cluster zu
deployn und auch Änderungen von deployten Anwendungen durchführen zu können, wo
etwa ein fehlerhaftes Deployment schon liegt.&lt;/p&gt;
&lt;p&gt;Die CNCF überarbeitet regelmäßig die Curricula für alle Zertifizierungen, und
ist somit meist recht aktuell für eine aktuelle Kubernetes Version. Die
aktuellen Informationen, inklusive der Gewichtung aller Themenblöcke
finden sich &lt;a href=&#34;https://github.com/cncf/curriculum&#34;&gt;in diesem GitHub-Repository&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Meine Prüfung fand im Juni 2021 statt, war also noch ein etwas älterer Stand.&lt;/p&gt;
&lt;p&gt;Zur Prüfungsvorbereitung habe ich zwei Dinge genutzt: &lt;a href=&#34;https://www.sandervanvugt.com/course/certified-kubernetes-application-developer-ckad-video-course/&#34;&gt;ein Video-Kurs von
Sander van
Vugt&lt;/a&gt;
und das Buch &lt;a href=&#34;https://www.oreilly.com/library/view/certified-kubernetes-application/9781492083726/&#34;&gt;Certified Kubernetes Appliaction Developer Study
Guide&lt;/a&gt;.
Ich habe Zugriff über den Arbeitgeber auf &lt;a href=&#34;https://www.oreilly.com/&#34;&gt;O&amp;rsquo;Reilly Learning Plattform&lt;/a&gt;,
wo beides enthalten war. Weiteren Kosten sind daher nicht entstanden.&lt;/p&gt;
&lt;p&gt;Ich hab mir zwar beides angeschaut, allerdings vieles nur überflogen, um möglichst
herauszufinden, was es bei der Prüfung zu beachten gibt und die Übungen zu machen.
Das eigentliche Doing war mir zumindest größtenteils bekannt. Ein paar Tipps
meinerseits folgen gleich.&lt;/p&gt;
&lt;p&gt;Wenn man die Grundlagen und die Themen aus dem Curriculum so weit beherrscht, empfehle
ich strengstens ein paar Übungsaufgaben zu machen und die Zeit dazu auch zu stoppen.
In der Prüfung hat man zwei Stunden Zeit, das ist knapp und man hat nur
wenig Zeit bei Problemen etwas zu debuggen.&lt;/p&gt;
&lt;p&gt;Folgende zwei GitHub-Repositories mit Beispielaufgaben und -lösungen habe ich
verwendet, um zu verifizieren, dass ich es so weit kann:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/dgkanatsios/CKAD-exercises&#34;&gt;dgkanatsios/CKAD-exercises&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/bmuschko/ckad-prep&#34;&gt;bmushko/ckad-prep&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Wer diese Aufgaben ohne Probleme in der Zeit lösen kann, sollte keine Probleme
bei der Prüfung haben.&lt;/p&gt;
&lt;h1 id=&#34;prüfung&#34;&gt;Prüfung&lt;/h1&gt;
&lt;p&gt;Zur Prüfung gibt es zwei Themen zu bereden:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Die „Vorbereitung“ auf die technische Durchführung der Prüfung ist super ätzend&lt;/li&gt;
&lt;li&gt;Tipps und Hinweise zur Prüfung selbst&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Nun, die Prüfung wird komplett Online durchgeführt. Man muss so gut wie alles
vom Tisch und den Wänden nehmen, damit man nicht spicken kann. Das wird ausführlich
überprüft, in dem man von einer Person im Chat unterhält. Leider ist die Person
wenig verständlich gewesen bei mir, sodass sich das ganze etwas gezogen hat und
ich ganze 30 Minuten damit beschäftigt war zu „beweisen“, dass ich einen leeren
Tisch und leere Wände habe.&lt;/p&gt;
&lt;p&gt;Zusätzlich muss man seinen Desktop komplett freigeben über eine Chrome
Extension, weil nur ein Tab mit der Kubernetes Dokumentation offen sein darf
und die Prüfung selbst. Andere Anwendungen dürfen nicht laufen. Ja, auch das
war super nervig, da ich den „Taskmanager“ zeigen sollte, um zu zeigen, dass
nichts läuft. Ich sollte dann noch „alle Anwendungen“ beenden, obwohl nur noch
KDE/Plasma Desktop-Teile liefen. Die hätte ich gerne beenden sollen. Ach ja und
die Lautsprecher, die bei mir quasi fix montiert sind, sollte ich auch
runternehmen. Ich durfte dann immerhin über die Webcam zeigen, dass ich es
abgestöpselt habe.&lt;/p&gt;
&lt;p&gt;Nach diesen 30 Minuten hatte ich schon echt kaum Lust auf die Prüfung, aber da
musste ich dann durch. Die Prüfung ist komplett praktisch. Sodass man diverse
Umgebungen gestellt bekommt, wo man die Übungen absolvieren muss. Das hat immerhin
problemlos funktioniert.&lt;/p&gt;
&lt;p&gt;Folgende Tipps allerdings noch meinerseits, damit die Prüfung erfolgreich absolviert
werden kann:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Versucht so viel YAML-Code durch &lt;code&gt;kubectl&lt;/code&gt; generieren zu lassen wie möglich.
Das spart sehr viel Zeit, die sonst fehlen würde. Außerdem wollt ihr nicht
YAML korrigieren wollen in so einer Situation. (Und auch sonst nicht.)&lt;/li&gt;
&lt;li&gt;Wenn ihr Probleme mit dem Lösen von Aufgaben habt, überspringt es zunächst
und macht alles, was ihr ohne Probleme schafft.&lt;/li&gt;
&lt;li&gt;Je mehr Übungen man vorher macht, desto einfacher wird es in der Prüfung selbst.&lt;/li&gt;
&lt;li&gt;Macht euch gewohnt an die Kubernetes Dokumentation und wie man da über die
interne Suche was findet. Googeln darf man nicht.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Innerhalb von 24h bekommt man die Resultate. Man braucht 66 von 100 Punkten. Ich
habe 87 erreicht. Unabhängig von der eher nervigen Prüfungsorganisation vor
dem Ablegen der Prüfung, habe ich gut was gelernt, da ich in meinem Homelab ja
auch nicht alles nutze und brauche.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Homeserver Setup 2021: k3s mit Flux und Helm</title>
      <link>https://svij.org/blog/2021/11/28/homeserver-setup-2021-k3s-mit-flux-und-helm/</link>
      <pubDate>Sun, 28 Nov 2021 18:30:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/11/28/homeserver-setup-2021-k3s-mit-flux-und-helm/</guid>
      <description>&lt;p&gt;Im Blogpost &lt;a href=&#34;https://svij.org/blog/2020/06/12/homeserver-setup-in-2020.../&#34;&gt;„Homeserver in 2020…“&lt;/a&gt;
beschrieb ich im Juni 2020, wie mein Homeserver-Setup damals aussah. In diesem
Blogpost gebe ich ein kleines Update, wie es heute, im Jahr 2021, aussieht.
Extremst viel hat sich nicht verändert, doch sind ein paar Funktionen dazu
gekommen, die die Wartung des Servers vereinfacht.&lt;/p&gt;
&lt;p&gt;Damals wie heute gilt: Ich will möglichst viel lernen und dabei Dienste einsetzen
und betreiben, die für mich einen gewissen Mehrwert haben. Das ist sowohl der
Funktionalität des Dienstes selbst, als auch die Installationsweise, die mich
in welcher Weise auch immer weiter bringt.&lt;/p&gt;
&lt;h1 id=&#34;k3s&#34;&gt;k3s&lt;/h1&gt;
&lt;p&gt;In der &lt;a href=&#34;https://tilpod.net/episode/til013-patriotische-sysadmins-gegen-die-kubernetisierung-der-serverlandschaft&#34;&gt;November-Ausgabe TIL013&lt;/a&gt; des Podcasts &lt;a href=&#34;https://tilpod.net&#34;&gt;TILpod&lt;/a&gt;,
den ich mit &lt;a href=&#34;https://dirk.deimeke.ruhr/&#34;&gt;Dirk Deimeke&lt;/a&gt; veröffentliche, erzählte
ich bereits in Tonform warum, wieso und weshalb ich auf &lt;a href=&#34;https://k3s.io/&#34;&gt;k3s&lt;/a&gt;
als Kubernetes-Distribution für meinen Homeserver betreibe. Wer die
Podcast-Folge gehört hat, wird hier eher wenig Neues lesen.&lt;/p&gt;
&lt;p&gt;Grundsätzlich betreibe ich, wie zuvor geschrieben, meinen Homeserver mit k3s.
Die Kubernetes-Distribution ist relativ „langweilig“: Es handelt sich um eine
leichtgewichtige Kubernetes-Distribution, die in einer einzelnen Binärdatei
ausgeliefert und installiert werden kann. Das macht die ganze Wartung auf
Dauer simpel. So kann ich ein Upgrade und Downgrade sehr simpel ausführen, in
dem ich die Binärdatei auf meinem Homeserver austausche. Das klappte grundsätzlich
auch immer. Upgrade-Probleme gibt es hingegen trotzdem, was allerdings mehr mit
Kubernetes als mit k3s selbst zu tun hatte.&lt;/p&gt;
&lt;p&gt;So gab es mal Probleme mit der Unterstützung von btrfs als Dateisystem in
Kubernetes generell, weshalb ein Upgrade fehlschlug. Zudem ändern sich häufiger
mal &lt;code&gt;apiVersion&lt;/code&gt; von Manifests, sodass man da auch mal nach einem Update
nacharbeiten muss. Aus diesem Grund schaue ich, dass ich möglichst häufig und
regelmäßig ein Upgrade von k3s ausführe, um mögliche Probleme frühzeitig zu
entdecken. Ansonsten ist man mit zu vielen Problemen gleichzeitig beschäftigt.&lt;/p&gt;
&lt;p&gt;Das klingt zwar jetzt grundsätzlich abschreckend, kam in den letzten ~2 Jahren
allerdings auch nur zwei Mal vor, dass mal größere Dinge nicht funktioniert haben,
ansonsten gab es da weitaus weniger Probleme.&lt;/p&gt;
&lt;h1 id=&#34;flux-und-helm&#34;&gt;Flux und Helm&lt;/h1&gt;
&lt;p&gt;Um meine Deployments auf den Cluster zu automatisieren, nutze ich &lt;a href=&#34;https://fluxcd.io/&#34;&gt;FluxCD&lt;/a&gt;.
Bis September 2021 setzte ich noch auf das „alte“ Flux v1. Danach führte ich
ein Upgrade auf Flux v2 durch, was durchaus eine nennenswerte Weiterentwicklung
ist, die nicht abwärtskompatibel zu v1 ist.&lt;/p&gt;
&lt;p&gt;Aber was tut es genau? Grundsätzlich bildet Flux den deklarativen Stand des
Repositories im Kubernetes-Cluster ab, neuerdings GitOps genannt. Das heißt im
konkreten, ich definiere im Repository – in einer gewissen Struktur – meine
Dienste. Ich verwende größtenteils wo es geht Helm Charts, da ich fast nur
Dienste hoste, die ich nicht selbst geschrieben habe.&lt;/p&gt;
&lt;p&gt;Als „Suchmaschine“ für Helm Charts verwende ich &lt;a href=&#34;https://artifacthub.io/&#34;&gt;ArtifactHUB&lt;/a&gt;.
Viele Helm-Charts sind allerdings ordentlich veraltet oder nicht gepflegt, von
daher prüfe ich immer, wie aktuell die Helm-Charts sind und von wem sie angeboten
wird. Es gibt zum Beispiel die Community &lt;a href=&#34;https://k8s-at-home.com/&#34;&gt;k8s-at-home&lt;/a&gt;
welche diverse Helm Charts zur Verfügung stellt, die ich nutze. Ansonsten sind
es häufig auch die Projekte selbst, die eigene Helm Charts anbieten, die ich
bevorzugt nutze. Dazu gehören zum Beispiel die Helm Charts von
&lt;a href=&#34;https://github.com/grafana/helm-charts&#34;&gt;Grafana&lt;/a&gt; und
&lt;a href=&#34;https://github.com/prometheus-community/helm-charts&#34;&gt;Prometheus&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Mein Lieblingsfeature von Flux 2 ist einfache und komfortable Möglichkeit, um
automatische Updates auszuführen. Früher hatte ich die Updates händisch
vorgenommen. Das heißt, ich habe die YAML-Dateien aufgemacht und händisch
jeweils geprüft, ob es eine neuere Version des Helm-Charts gibt. Bei so zehn
Anwendungen, die ich so betrieben hatte, war das etwas nervig, weil das viel
unnötige Arbeit war.&lt;/p&gt;
&lt;p&gt;Mit Flux 2 gebe ich nur noch an, in welcher Versionen ich die Helm-Charts installieren
möchte. Für Grafana sieht meine Zeile aktuell etwa so aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;version: &amp;quot;&amp;gt;=6.16.6 &amp;lt;7.0.0&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Es wird also mindestens die Helm Chart Version von Grafana 6.16.6 installiert
und wird kein Upgrade auf die nächste Major Version 7.0.0 durchgeführt.
Dieses Vorgehen mache ich für alle meine Helm-Charts, sodass ich keinen Aufwand
für Upgrades habe. Ausgenommen sind Major-Releases, weil sich da häufiger mal das
Format der &lt;code&gt;values.yaml&lt;/code&gt; ändert. Manchmal wird es allerdings auch schon vorher
geändert, was zwar auch ein wenig umständlich ist, aber das passiert zum Glück
eher nicht so häufig.&lt;/p&gt;
&lt;p&gt;Das automatische Upgrade von Versionen hab ich nun seit drei Monaten im Einsatz.
Um Upgrades zusätzlich mitzubekommen, habe ich die genutzten Helm-Charts über
&lt;a href=&#34;https://artifacthub.io&#34;&gt;ArtifactHUB&lt;/a&gt; abonniert. Wenn also neue Updates veröffentlicht
werden, erhalte ich eine E-Mail. So behalte ich Überblick über neue Major-Releases
von mir genutzten Helm-Charts, um manuell das Upgrade durchzuführen.&lt;/p&gt;
&lt;h1 id=&#34;anwendungen&#34;&gt;Anwendungen&lt;/h1&gt;
&lt;p&gt;Bei den Anwendungen hat sich in den letzten 1,5 Jahren nicht so viel geändert:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://nextcloud.com/&#34;&gt;Nextcloud&lt;/a&gt; für Kalender, Kontakte und Dateisynchronisation&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/dani-garcia/vaultwarden&#34;&gt;Vaultwarden&lt;/a&gt; als Passwortmanager (Reimplementation von Bitwarden)&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://prometheus.io/&#34;&gt;Prometheus&lt;/a&gt; für das Monitoring&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://grafana.com&#34;&gt;Grafana&lt;/a&gt; für die Visualisierung der Daten aus Prometheus, Influx und PostgreSQL&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://about.gitlab.com&#34;&gt;GitLab&lt;/a&gt; für Git-Repositorys&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://ui.com&#34;&gt;Unifi&lt;/a&gt; Controller für meine Unifi APs&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://syncthing.net&#34;&gt;Syncthing&lt;/a&gt; für das Synchronisieren von Backups zu einer Offsite-Stelle&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://rclone.org&#34;&gt;rclone&lt;/a&gt; als Cronjob für das Hochladen von Backups „in die Cloud“&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://gitlab.com/svij/kostal-dataexporter&#34;&gt;Dataexporter der Photovoltaik-Anlage&lt;/a&gt;, der die Daten in eine Influx und PostgreSQL Datenbank schreibt&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.influxdata.com/&#34;&gt;Influxdb&lt;/a&gt; für die Daten der PV-Anlage, sowie Stromverbrauch und Temperatur-Sensoren&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.postgresql.org/&#34;&gt;PostgreSQL&lt;/a&gt; für Nextcloud, Kostal Datenhaltung und GitLab&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://jellyfin.org/&#34;&gt;Jellyfin&lt;/a&gt; für Multimedia-Daten, ersetzte Plex&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://min.io/&#34;&gt;minio&lt;/a&gt; als S3-kompatibles Object-Storage-Backend für GitLab&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://traefik.io&#34;&gt;traefik&lt;/a&gt; als Reverse Proxy&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.home-assistant.io/&#34;&gt;Home-Assistant&lt;/a&gt; für Smart-Home&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://mosquitto.org/&#34;&gt;mosquitto&lt;/a&gt; als MQTT broker&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/jonaswinkler/paperless-ng&#34;&gt;paperless-ng&lt;/a&gt; für Dokumenten-Management&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/pdreker/fritz_exporter&#34;&gt;fritz_exporter&lt;/a&gt; um Fritz!Box Daten für Prometheus zu exportieren&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://aquasecurity.github.io/starboard/v0.13.0/&#34;&gt;starboard&lt;/a&gt; um die Container-Images im Cluster zu scannen&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Außerhalb von Kubernetes läuft sonst weiterhin
&lt;a href=&#34;https://svij.org/blog/2016/11/12/verteiltes-backup-konzept-mit-borg/&#34;&gt;borgbackup&lt;/a&gt; und sonst
eigentlich nichts mehr.&lt;/p&gt;
&lt;p&gt;In Zukunft werd ich noch einiges mehr ausprobieren müssen. Zum Beispiel
&lt;a href=&#34;https://argo-cd.readthedocs.io/en/stable/&#34;&gt;ArgoCD&lt;/a&gt; statt Flux. Ansonsten sind
noch etliche Projekte in der &lt;a href=&#34;https://github.com/cncf/landscape/blob/master/README.md#trail-map&#34;&gt;CNCF Landscape Trail Map&lt;/a&gt;
die man sich anschauen kann.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Canon-DSLR als Webcam mit HDMI-Output und Magic Lantern</title>
      <link>https://svij.org/blog/2021/08/29/canon-dslr-als-webcam-mit-hdmi-output-und-magic-lantern/</link>
      <pubDate>Sun, 29 Aug 2021 18:50:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/08/29/canon-dslr-als-webcam-mit-hdmi-output-und-magic-lantern/</guid>
      <description>&lt;h1 id=&#34;problem&#34;&gt;Problem&lt;/h1&gt;
&lt;p&gt;Vor etwas weniger als &lt;a href=&#34;https://svij.org/blog/2020/11/22/canon-dslr-als-webcam-auf-linux-systemen-verwenden/&#34;&gt;einem Jahr&lt;/a&gt;
bloggte ich bereits über mein Webcam-Setup, wo ich beschrieb, wie man eine
Canon DSLR per Mini-USB unter Linux zum Laufen bringt. Das funktioniert zwar
technisch, hatte aber ein paar Einschränkungen und Dinge, die mich nervten,
weshalb ich das Setup wieder umgebaut habe. Hauptproblem: Das Setup braucht
ein geladenes Kernel-Modul und bei jedem Anschalten der Kamera musste eine lange
Befehlskette neu gestartet werden. Zudem war es nur das Preview-Bild was
abgegriffen wurde. Das entsprach dann einer Auflösung von lediglich 960x640.&lt;/p&gt;
&lt;h1 id=&#34;hardware&#34;&gt;Hardware&lt;/h1&gt;
&lt;p&gt;Praktischer ist daher die Nutzung des HDMI-Ausgangs über ein HDMI-Capture Stick.
Ich nutze dafür den Elgato Cam Link 4K. Der Stick wird direkt als Webcam identifiziert
und kann ohne Probleme in jegliche Videokonferenztools genutzt werden.&lt;/p&gt;
&lt;p&gt;Theoretisch wäre dieser Blogpost schon zu Ende. Allerdings fiel nach dem ersten
Betrieb schon ein Problem auf: Über den HDMI-Ausgang wirft meine Canon 700D kein
sauberes Bild aus, da dort typische Kamera Einstellungen und Darstellungen auf
dem Bildschirm dargestellt werden, die auch über HDMI ausgegeben werden. Größeres
Problem allerdings: Die Kamera schaltet den Live-View Modus nach 30min automatisch
ab. Somit ist es nicht sonderlich gut nutzbar, dies war über USB nämlich kein
Problem.&lt;/p&gt;
&lt;h1 id=&#34;magic-lantern&#34;&gt;Magic Lantern&lt;/h1&gt;
&lt;p&gt;Zu dem Problem gibt es aber eine weitere Lösung: Mit &lt;a href=&#34;https://magiclantern.fm/&#34;&gt;Magic Lantern&lt;/a&gt;,
eine Open Source Firmware für diverse Canon Kameras. Die Firmware wird dabei
von der SD-Karte gestartet, nachdem man zuvor das passende Firmware-Update für
die Kamera selbst installiert hat. Scheinbar gibt es aber für Magic Lantern selbst
seit 3 Jahren keine Updates mehr. Für meinen Zweck ist das noch verkraftbar.&lt;/p&gt;
&lt;p&gt;In den Einstellungen von Magic Lantern lassen sich dann extremst viele Konfigurationen
einstellen, um mehr aus der Kamera herauszuholen zu können. In meinem Fall war ich
da lediglich daran interessiert, das Auto-Abschalten des Live-Views zu deaktivieren.&lt;/p&gt;
&lt;h1 id=&#34;einschränkungen&#34;&gt;Einschränkungen&lt;/h1&gt;
&lt;p&gt;Auch mit diesem Setup gibt es ein paar Einschränkungen, sonst wäre es ja langweilig.
So hat das Live-View Bild im P-Modus der Kamera eine schwarzen Kasten, der auch so
über HDMI ausgegeben wird. Im Automatik-Modus ist das zum Glück nicht der Fall,
aber auch da hat man zumindest am linken und rechten Rand schwarze Balken, was
dem Kamera-Format geschuldet ist. Dies kann man, wenn man möchte, über Software wie
OBS croppen, aber das möchte ich in meinem Fall nicht.&lt;/p&gt;
&lt;p&gt;Reguläre Webcams sind immerhin mittlerweile lieferbar zu bezahlbaren Preisen, im
Gegensatz zum letzten Jahr. Ich bleibe nun erstmal bei dem Setup, alles andere
wäre schließlich zu einfach (und zu günstig).&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Monorepo(s) mit Git: Eine gute Idee?</title>
      <link>https://svij.org/blog/2021/05/16/monorepos-mit-git-eine-gute-idee/</link>
      <pubDate>Sun, 16 May 2021 23:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/05/16/monorepos-mit-git-eine-gute-idee/</guid>
      <description>&lt;p&gt;Seit etwas über einem Jahr arbeite ich bei GitLab und habe engen Kontakt mit
Kunden, die entweder schon GitLab einsetzen oder bald einsetzen werden. Ein
Thema was zuletzt immer häufiger aufkommt, ist das Thema „Monorepo“. Noch
spannender ist, wie einige Kunden sagen, sie haben „mehrere Monorepos“, was
keinen Sinn ergibt. Denn nicht umsonst setzt sich das Wort auf „mono“ und „repo“
zusammen, also „einzel“ und „Repository“. Im Endeffekt hat man also ein großes
Repository wo &lt;strong&gt;der komplette&lt;/strong&gt; Quellcode enthalten und verwaltet wird.
Jedes Mal, wenn ein Kunde von „mehreren Monorepos“ spricht, dann zwickt mein Auge
immer wieder stark, denn meistens ist damit eigentlich nur gemeint, dass es sich um
„Multi-Projekt Repositorys“ handelt. Also sind es meist eher Repositorys wo
mehrere Projekte innerhalb eines Repositorys verwaltet werden.&lt;/p&gt;
&lt;p&gt;Stellenweise finden sich im Internet diverse Blogposts wo Monorepos die Abkürzung
von „monolithisches Repository“ ist. Das ist nicht die Definition, die ich wählen
würde und auch nicht die, die gängig verbreitet ist. Ein Monolith aus Sicht der
Software-Entwicklung kann schließlich auch aus mehreren Repositorys bestehen –
und tut es in vielen Umgebungen auch. Überschneidungen gibt es hier aber sicherlich.&lt;/p&gt;
&lt;p&gt;Echte Monorepos finden sich in der freien Wildbahn eher selten. Der wohl bekannteste
Vertreter ist Google. Google hat für ihre internen Tools ein großes Repository,
was nicht auf Git aufsetzt, sondern eine proprietäre Eigenentwicklung ist.
Enthalten ist dort der Quellcode und die Versionshistorie der ganzen Firma seit
Anbeginn der Zeit. In einem &lt;a href=&#34;https://dl.acm.org/doi/pdf/10.1145/2854146&#34;&gt;Paper von Juli 2016&lt;/a&gt;
beschreiben sie recht ausführlich, wie ihr Monorepo aufgebaut ist, wie sie
damit Arbeiten und wie groß es mittlerweile ist. Wem die Details interessieren,
sollte da mal reinlesen. Knapp 5 Jahre später dürfte das Repository noch deutlich
riesiger geworden sein.&lt;/p&gt;
&lt;p&gt;Ein weiterer bekannter Nutzer von Monorepos sind weitere große Techfirmen wie
Facebook, Microsoft oder Twitter. Bei jeder Firma dürfte die Nutzung durchaus
unterschiedlich sein. Facebook setzt beispielsweise auf Mercurial als SCM tool.
Details darüber schrieben sie im Blogpost „&lt;a href=&#34;https://engineering.fb.com/2014/01/07/core-data/scaling-mercurial-at-facebook/&#34;&gt;Scaling Mercurial at Facebook&lt;/a&gt;“.
Der Artikel ist von Januar 2014, also auch schon etwas älter.&lt;/p&gt;
&lt;h1 id=&#34;warum-überhaupt-monorepos&#34;&gt;Warum überhaupt Monorepos?&lt;/h1&gt;
&lt;p&gt;Egal ob man mit multiplen Repositorys arbeitet oder mit einem Monorepo: Beide
Varianten haben je nach betrachteten Aspekt Vor- und Nachteile. Während man bei
einem Monorepo-Ansatz vielleicht nicht die Probleme des Multi-Repo-Ansatzes
hat, bekommt man stattdessen andere Herausforderungen.&lt;/p&gt;
&lt;p&gt;Statt hier plump die Vor- und Nachteile beider Varianten einzugehen, verfolge
ich hier einen etwas anderen Ansatz und beleuchte einzelne Aspekte und Methodiken
mit beiden Varianten. Dies betrifft sowohl technische Herausforderungen vom
eingesetzten Versionsverwaltungsprogramm, als auch die Build-Tools, sowie die
Arbeitsweise.&lt;/p&gt;
&lt;h2 id=&#34;internes-dependency-managements&#34;&gt;Internes Dependency-Managements&lt;/h2&gt;
&lt;p&gt;Ein wichtiger Grund für ein Monorepo (oder auch Multi-Projekt-Repository) ist
die vereinfachte Möglichkeit des Managements von internen Abhängigkeiten. Und
dieser Use-Case ist generell gar nicht mal so selten.&lt;/p&gt;
&lt;p&gt;Häufig sieht es so aus, dass es innerhalb einer Firma mehrere Projekte gibt,
welche die gleiche Abhängigkeit nutzen. Soweit nichts Besonderes. Aber wie sieht
nun der Vorgang aus, wenn eine Änderung an der Abhängigkeit gemacht werden muss?&lt;/p&gt;
&lt;p&gt;Im klassischen Konzept, also ohne einem Monorepo, werden gleich jeweils eine Änderung
an zwei Repositorys benötigt: Einmal in der Library, wo die eigentliche Änderung
durchgeführt wird und anschließend die nächste Änderung im Hauptprojekt. Diese
ist allerdings abhängig von der Änderung der Abhängigkeit. Hier muss also erst
einmal abgewartet werden, bis die Änderung eingeflossen ist, bevor so wirklich
die Änderung im Hauptprojekt gemacht werden kann. Der Prozess dauert also automatisch
etwas länger und führt zu längeren Entwicklungszeiten. Zusätzlich könnte auch
noch sein, das mehrere Projekte diese Abhängigkeit verwenden und diese auch
eine Änderung benötigen, diese muss – auch wenn es sich vielleicht nur um eine
kleine Anpassung handelt – in jedem Projekt nachgepflegt werden.&lt;/p&gt;
&lt;p&gt;Hier ist also schonmal ein wesentlicher Vorteil von Monorepos beziehungsweise
Multi-Projekt-Repos: Eine Änderung in einer Abhängigkeit kann in einem Rutsch
und einem Review durchgeführt werden. Komplexere Abhängigkeiten beim Mergen
von Änderungen über verschiedene Repositorys hinweg wird vermieden und das
Review ist gleichzeitig transparenter durchführbar, da man in einer Ansicht
und mit einem Review projektübergreifend die Änderung überblicken kann.&lt;/p&gt;
&lt;p&gt;Was ich hier allerdings noch nicht betrachtet habe, ist das CI (und CD) Setup,
denn das hat auch einen wesentlichen Einfluss auf die Arbeitsweise. Aber
dazu im nächsten Abschnitt mehr.&lt;/p&gt;
&lt;h2 id=&#34;cicd-und-build-tools&#34;&gt;CI/CD und Build Tools&lt;/h2&gt;
&lt;p&gt;Ein weiterer Aspekt der wichtig zu betrachten ist, ist das Setup rund um CI/CD
und den Build Tools. Wie im Abschnitt zuvor schon erwähnt steht und fällt es
der verwendete Ansatz an den Tools und Workflows.&lt;/p&gt;
&lt;p&gt;Um das Beispiel aus dem vorherigen Abschnitt fortzuführen ist es nun wichtig
zu betrachten, wie der Build-Prozess nun aussieht. Im traditionellen Umfeld
mit mehreren Repositorys hat jedes Projekt im Repository meistens eine Pipeline-Definition,
welche bei jedem Merge-Request ausgeführt wird, um das Projekt zu bauen und
zu testen. Kompliziert wird es aber, wenn man es auch „richtig“ testen will und
das ist gar nicht so einfach.&lt;/p&gt;
&lt;p&gt;Angenommen, die Abhängigkeit mit dem Namen „DependencyA“ ist die Abhängigkeit
von „HauptprojektA“ und „HauptprojektB“. Wenn also für eine Änderung in „HauptprojektA“
eine Änderung in „DependencyA“ benötigt wird, dann muss diese Änderung da normal
eingepflegt werden, worin dann die Pipeline läuft und das Projekt baut und die
Tests ausführt. Wenn es erfolgreich war, dann wird ggf. eine neue Version getaggt,
damit es dann von „HauptprojektA“ und „HauptprojektB“ referenziert und verwendet
werden kann. Dort müssen dann nochmals Merge Requests erzeugt werden, die dann
die Version von „DependencyA“ hochziehen und dann alles Bauen und Testen.&lt;/p&gt;
&lt;p&gt;Das ist im Prinzip das, was ich auch zum internen Dependency-Management geschrieben
habe. Das Problem hierbei ist, dass immer nur jedes Projekt für sich getestet
wird, aber nicht alle Projekte als ganzes. Das heißt im Konkret, wenn die Änderung
in „DependencyA“ zu einem Fehler im „HauptprojektB“ führt, muss der ganze Workflow
wieder von vorne gestartet werden.&lt;/p&gt;
&lt;p&gt;Was häufig aber fehlt, ist die Möglichkeit alle Projekte zu bauen, die voneinander
abhängen für die einzelne Änderung. Das heißt, ich mache eine Änderung an
„DependencyA“, die Pipeline baut nicht nur das Projekt selbst und testet es, sondern
es zieht bei „HauptprojektA“ und „HauptprojektB“ die Änderung „trocken“ mit und
baut es im gleichen Zuge auch mit durch und führt die Tests aus. So kann
sichergestellt werden, dass die Änderung nicht zu Folgefehlern in den
eigentlichen Projekten führt.&lt;/p&gt;
&lt;p&gt;Beim Einsatz von mehreren Repositorys ist das nicht soo einfach zu lösen, da
theoretisch automatisiert in den entsprechenden Reverse-Dependency-Projekten
neue Branches mit den Änderungen erstellt werden müssen, um die Pipeline zu triggern.
Oder es muss eine andere Art der Parametrisierung eingebaut werden, um dies zu
bewerkstelligen. &lt;a href=&#34;https://zuul-ci.org&#34;&gt;zuul-ci.org&lt;/a&gt; ist ein Projekt um so etwas
umzusetzen. Praktische Erfahrung habe ich damit allerdings nicht.&lt;/p&gt;
&lt;p&gt;In Monorepos ist das grundsätzliche Problem eine Änderung in allen Projekten
durchzubauen auch enthalten, ist da aber grundsätzlich einfacher zu verwalten,
weil es eben in einem Repository enthalten ist. Nichtsdestotrotz wird auch
hier ein eigenes bzw. spezielles Buildtool benötigt, was selbstständig die
Abhängigkeiten auf allen Projekten im Repository erkennt und entsprechend
durchbaut. Das Buildtool &lt;a href=&#34;https://www.bazel.build/&#34;&gt;Bazel&lt;/a&gt; unterstützt das und
baut etwa nur die Änderungen durch, die auch wirklich benötigt werden.&lt;/p&gt;
&lt;h2 id=&#34;kollaborationen-im-team-und-zwischen-teams&#34;&gt;Kollaborationen im Team und zwischen Teams&lt;/h2&gt;
&lt;p&gt;Beim Arbeiten über den Grenzen von verschiedenen Teams ist die Abstimmung bei
Änderungen essenziell. Beim Einsatz von mehreren Repositorys sind die
Verantwortlichkeiten über die Repository-Berechtigungen selbst gesetzt. Die Hürde
bei „fremden“ Teams die Änderung an einer gemeinsam genutzten Abhängigkeit und
beim Projekt selbst einzubringen ist häufig eher hoch. Aber das ist mehr eine
organisatorische und auch kulturelle Frage.&lt;/p&gt;
&lt;p&gt;In Monorepos und Multi-Projekt-Repos ist das nicht so einfach möglich, weil sich
hier das klassische Modell nicht anwenden lässt. Dafür gibt es allerdings das
Konzept der &lt;code&gt;CODEOWNERS&lt;/code&gt; wo sich eintragen lässt, welcher User der „Eigentümer“
welches Unterverzeichnisses ist, damit diese im Code-Review automatisch
benachrichtigt werden und nur diese es mergen dürfen. Diese Funktion ist keine
Funktion von Git selbst, sondern wird von den verschiedenen Git-Hosting-Diensten
selbst implementiert. In GitLab ist die &lt;a href=&#34;https://docs.gitlab.com/ee/user/project/code_owners.html&#34;&gt;Code Owners Funktionalität&lt;/a&gt;
kostenpflichtig, in GitHub &lt;a href=&#34;https://docs.github.com/en/github/creating-cloning-and-archiving-repositories/about-code-owners&#34;&gt;je nach Visbilität des Projekts auch&lt;/a&gt;.&lt;/p&gt;
&lt;h1 id=&#34;git-funktionen-für-große-repositorys&#34;&gt;Git Funktionen für große Repositorys&lt;/h1&gt;
&lt;p&gt;Bisher habe ich mich hauptsächlich mit den konzeptionellen Vor- und Nachteilen
beschäftigt. Fakt ist allerdings, dass die echten Vor- und Nachteile sehr stark
von den eigentlichen Firmen, Strukturen und Projekten ab.&lt;/p&gt;
&lt;p&gt;Bisher habe ich nicht nur die Arbeitsweise und Workflows betrachtet, weniger
wie gut bzw. schlecht es mit Git selbst funktioniert. Darum geht es nun in den
folgenden Abschnitten.&lt;/p&gt;
&lt;h2 id=&#34;performance&#34;&gt;Performance&lt;/h2&gt;
&lt;p&gt;Das Git von Haus aus nicht wirklich für große Repositorys gemacht ist, ist vielen
mittlerweile hinlänglich bekannt, da alle Versionen aller Dateien im Standard
im Repository enthalten sind. Je mehr Dateien und Verzeichnisse sind, desto
eher wird die Performance leiden. Dies ist nicht nur daran geschuldet, dass das
Repository sehr groß (in Gigabyte gemessen) wird, sondern auch, dass nicht
effizient mit mehreren Millionen von Dateien umgehen kann.&lt;/p&gt;
&lt;p&gt;Wie sich das ganze Auswirken kann, zeigt &lt;a href=&#34;https://www.youtube.com/watch?v=g_MPGU_m01s&#34;&gt;ein Konferenz-Vortrag von Microsoft: „Scaling Git at Microsoft“&lt;/a&gt;.
Dort wird erzählt welche Probleme Microsoft hatte, um das Windows Repository
auf Git zu migrieren. Es resultierte in ein 270GB großes Repository, wo das
Klonen 12h gedauert hat, ein &lt;code&gt;git checkout&lt;/code&gt; 3h, das Ausführen von &lt;code&gt;git status&lt;/code&gt;
auch immerhin 8 Minuten und Ausführen von &lt;code&gt;git commit&lt;/code&gt; dauerte auch schon
mal eben 30 Minuten. Alles wohlgemerkt auf SSDs. Aus technischer Sicht ist das
ein sehr spannender Vortrag, bei dem ich erst richtig verstanden hab, was für
Probleme Git bei großen Repositorys hat.&lt;/p&gt;
&lt;p&gt;Allerdings muss man sowieso hervorheben, dass wohl die wenigsten Projekte
wirklich so große Repositorys haben werden.&lt;/p&gt;
&lt;h2 id=&#34;git-lfs&#34;&gt;Git LFS&lt;/h2&gt;
&lt;p&gt;Ein angesprochenes Problem von Git ist wie zuvor erwähnt die Handhabung von
Binärdateien. Dazu gibt es Git LFS, womit sich Binärdateien außerhalb des eigentlichen
Git-Repositorys von Git speichern und verwalten lassen. Der einzige Zweck ist
wirklich nur die Handhabung von Binärdateien und weniger von generellen großen
Repositorys.&lt;/p&gt;
&lt;p&gt;In einem &lt;a href=&#34;https://svij.org/blog/2017/04/17/binardateien-effizienter-in-git-repositorys-nutzen-mit-git-lfs/&#34;&gt;separaten Blogpost&lt;/a&gt;
habe ich das Thema Git LFS näher beleuchtet.&lt;/p&gt;
&lt;h2 id=&#34;git-submodule-und-git-subtree&#34;&gt;git submodule und git subtree&lt;/h2&gt;
&lt;p&gt;Wenn man mit mehreren Repositorys arbeitet, gibt es verschiedene Möglichkeiten
die Abhängigkeiten mit hereinzuziehen. Wenn diese Abhängigkeiten einfach über
den Paketmanager der verwendeten Programmiersprache verwendet werden kann, ist
es am einfachsten. Wenn man allerdings den Code einer Abhängigkeit direkt in
das Hauptprojekt einbinden muss, dann gibt es die Möglichkeit mit Submodulen
zu arbeiten. Die eher unbekanntere Methode ist Subtree zu nutzen.&lt;/p&gt;
&lt;p&gt;Beide Varianten haben Vor- und Nachteile. Die Handhabung von &lt;code&gt;git submodule&lt;/code&gt;
ist eher aufwändig und mühselig. Es müssen relativ viele Schritte durchgeführt
werden, damit alles ordnungsgemäß funktioniert. Mit &lt;code&gt;git subtree&lt;/code&gt; kann man hingegen
das Zurückführen der Änderung gut und gerne mal vergessen, ist dafür aber
angenehmer zu nutzen.&lt;/p&gt;
&lt;p&gt;Auch auf diese beiden Befehle gehe in einem &lt;a href=&#34;https://svij.org/blog/2019/11/10/git-subtree-eine-alternative-fur-git-submodule/&#34;&gt;weiteren Blogpost&lt;/a&gt;
näher darauf ein.&lt;/p&gt;
&lt;h2 id=&#34;git-sparse-checkout&#34;&gt;git sparse-checkout&lt;/h2&gt;
&lt;p&gt;Sowohl &lt;code&gt;git submodule&lt;/code&gt; als auch &lt;code&gt;git subtree&lt;/code&gt; waren zwei Funktionen, die eher nicht
für Monorepos relevant sind. Was hingegen relevant ist, ist die Möglichkeit
nur mit einem Teil des Repositorys arbeiten zu können. Ein gängiges &lt;code&gt;git clone&lt;/code&gt;
lädt schließlich das komplette Repository herunter, was bei einem echten Monorepo
eher ungünstig ist, da man dann auch allen Code lokal vorliegen hat, den man
gar nicht braucht. Mit einem Sparse-Checkout lässt sich ein Klonen und Arbeiten
mit einzelnen Unterverzeichnissen bewerkstelligen.&lt;/p&gt;
&lt;p&gt;Das GitHub-Blog hat einen ausführlichen &lt;a href=&#34;https://github.blog/2020-01-17-bring-your-monorepo-down-to-size-with-sparse-checkout/&#34;&gt;Blogpost&lt;/a&gt;
veröffentlicht in dem genauer beschrieben wird, wie man mit &lt;code&gt;git sparse-checkout&lt;/code&gt;
arbeiten kann, damit das Arbeiten mit einem Monorepo überhaupt erst halbwegs
ordentlich möglich ist.&lt;/p&gt;
&lt;h1 id=&#34;fazit&#34;&gt;Fazit&lt;/h1&gt;
&lt;p&gt;Wenn ihr nun diesen Blogpost gelesen habt, habt ihr vielleicht das Gefühl, dass
die Vorteile den Nachteilen von Monorepos überwiegen und dies auch meine Einstellung
ist. Tatsächlich ist diese Frage gar nicht so einfach zu beantworten.&lt;/p&gt;
&lt;p&gt;Prinzipiell bin ich kein großer Fan von Monorepos. Die meisten Firmen dürften
viel zu klein sein, um überhaupt die Vorteile von Monorepo-Ansätzen profitieren
zu können. Die Nachteile überwiegen da häufig, da eher speziellere Tools für das
Bauen und Verwalten der ganzen Toolchain gebraucht wird, die zu meist auch
komplexer sind. Und ich meine hier ganz bewusst &lt;strong&gt;echte&lt;/strong&gt; Monorepos und nicht
Multi-Projekt-Repositorys. Die sind nicht ganz so komplex und umspannen in der
Regel nicht völlig verschiedene Teams, Abteilungen die nichts miteinander zu
tun haben.&lt;/p&gt;
&lt;p&gt;Bei ganz großen Firmen sieht das natürlich anders aus, aber sehr viele ähnlich
große Firmen die vergleichbar mit Microsoft, Google oder Twitter sind, gibt es
dann doch eher seltener. Und die haben auch genug Personal, um spezielles eigenes
Tooling zu entwickeln.&lt;/p&gt;
&lt;p&gt;Was man hingegen nicht verleugnen sollte, ist der Fakt, dass an Git aktuell vor
allem Verbesserung bei der Handhabung von großen Repositorys sichtbar ist. Da
dürften noch viele weitere Neuigkeiten mit einfließen, so wie &lt;code&gt;git sparse-checkout&lt;/code&gt;
ein relativ neues Feature ist.&lt;/p&gt;
&lt;p&gt;Unabhängig davon: Das Thema Monorepos haben &lt;a href=&#34;https://www.deimeke.net/dirk/blog/&#34;&gt;Dirk&lt;/a&gt;
und ich in unserem Podcast &lt;a href=&#34;https://tilpod.net&#34;&gt;TILpod&lt;/a&gt; in Folge &lt;a href=&#34;https://tilpod.net/episode/til006-multiple-monorepos&#34;&gt;TIL006&lt;/a&gt;
besprochen mit einer etwas anderen Art und Weise.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>E-Book Reader: Onyx BOOX Note3 im Einsatz</title>
      <link>https://svij.org/blog/2021/05/08/e-book-reader-onyx-boox-note3-im-einsatz/</link>
      <pubDate>Sat, 08 May 2021 19:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/05/08/e-book-reader-onyx-boox-note3-im-einsatz/</guid>
      <description>&lt;p&gt;Lesen ist etwas, was ich generell viel zu wenig mache. Auf gedruckten Papier habe ich
seit Ewigkeiten nicht mehr gelesen. Schon seit einigen Jahre besitze ich zwar
einen Kindle Paperwhite von Amazon, aber die Nutzung variierte stark. Mal mehr,
mal gar nicht.&lt;/p&gt;
&lt;p&gt;Ein paar Gründe führten zu dem Umstand, dass ich das Kindle weniger genutzt habe:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Es ist von Amazon und ich versuche aus verschiedenen Gründen so wenig bei Amazon wie möglich zu kaufen. Vor allem keine Bücher, da dann am wenigstens beim Autor hängen bleibt. (Kauft am besten beim Verlag!)&lt;/li&gt;
&lt;li&gt;Keine Unterstützung für &lt;code&gt;.epub&lt;/code&gt; und somit Zwang auf Tools wie Calibre zu setzen.&lt;/li&gt;
&lt;li&gt;Keine (gute) Unterstützung für PDF-Dateien.&lt;/li&gt;
&lt;li&gt;Keine (gute) Möglichkeit Annotationen an Dokumenten zu erstellen.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Die letzten beiden Use-Cases sind speziellere Funktionen die ich nicht so
häufig brauche. Als Autor und somit bei der Arbeit an der &lt;a href=&#34;https://svij.org/blog/2021/03/03/dritte-auflage-meines-git-buches-erschienen/&#34;&gt;dritten Auflage meines
Git Buches&lt;/a&gt;
muss ich mehrfach vor der Drucklegung die Fahne Korrekturlesen. Ich weiß, dass
beim Verlag sehr viel gedruckt wird, weil es sich einfach besser liest als auf
einem Bildschirm und dann mit Stift Anmerkungen gemacht werden. Ich hatte das
eine Weile lang auf einem Android Tablet gemacht, das war aber wegen des Displays
eher auf der Kategorie „nicht so geil zum Lesen“. Notizen für Korrekturen waren auch eher umständlich
und zudem besitze ich gar kein Tablet mehr.&lt;/p&gt;
&lt;p&gt;Ich wollte also mehr Lesen und wollte auch die Möglichkeit haben, Notizen machen
zu können, idealerweise mit Stift.&lt;/p&gt;
&lt;p&gt;Zur Wahl standen letztendlich drei Geräte:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://remarkable.com/store/remarkable-2&#34;&gt;reMarkable 2&lt;/a&gt; (458€)&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.boox.com/noteair&#34;&gt;Onyx BOOX Note Air&lt;/a&gt; (479,99€)&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.boox.com/note3&#34;&gt;Onyx BOOX Note 3&lt;/a&gt; (549,99€)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Alle drei Geräte sind E-Book-Reader mit guter Funktionalität um Notizen machen
zu können. Das reine Lesen von Büchern ist ja eher der langweilige Part. Alle
Geräte besitzen ein 10,3&amp;quot; großes Display. Die Größe war wichtig, damit das Machen von Notizen
auf einem nicht ganz so kleinem Gerät erfolgen muss. Ich hatte zwar Angst, dass
es zu groß sein könnte, aber das war dann doch passend.&lt;/p&gt;
&lt;p&gt;Gekauft habe ich letztendlich das Onyx BOOX Note 3. Und hab mich im Wesentlichen
gegen ein reMarkable entschieden, was die eher bekanntere Marke ist. Meine Gründe
sind folgende:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Das reMarkable ist an die Hersteller-Cloud gebunden (Minus-Punkt)&lt;/li&gt;
&lt;li&gt;Das Onyx BOOX läuft mit Android und ohne Zwang zur Bindung an Google (Plus-Punkt)&lt;/li&gt;
&lt;li&gt;Das Onyx BOOX kann ohne Hersteller-Cloud und somit relativ „frei“ betrieben werden&lt;/li&gt;
&lt;li&gt;Kollege Dirk hatte mal ein reMarkable 1 und kaufte sich später ein Onyx BOOX Max 3, &lt;a href=&#34;https://www.deimeke.net/dirk/blog/index.php?/archives/4008-Onyx-Boox-Max-3.html&#34;&gt;darüber schreibt er auch in seinem Blog&lt;/a&gt;, und ist sehr zufrieden (Plus-Punkt)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Der Preis war natürlich nicht ganz so klein, aber man gönnt sich ja sonst nichts.&lt;/p&gt;
&lt;p&gt;Grundsätzlich hat sich der Kauf gelohnt, es tut genau das, was es soll und es kommen
auch Updates mit weiteren Funktionen. Die Notiz-Funktion habe ich nicht nur für
die Korrekturen an meinem Buch genutzt, sondern auch für generelle Notizen, um
ablenkungsfrei Nachdenken zu können. Die App dafür hat sehr viele Funktionen,
wovon ich für meinen Zweck nicht so viel brauche.&lt;/p&gt;
&lt;p&gt;Diejenigen die sich für richtig tiefe Reviews für solche Geräte interessiert, denen
kann ich den YouTube-Kanal &lt;a href=&#34;https://www.youtube.com/c/MyDeepGuide&#34;&gt;My Deep Guide&lt;/a&gt;
empfehlen, wo der Herr die verschiedensten E-Book-Reader miteinander vergleicht.
Es gibt einen sehr guten Eindruck was die Geräte können und in welchen Aspekten
die Geräte besser als die anderen sind.&lt;/p&gt;
&lt;p&gt;Die Anzahl an Android Apps hab ich gering gehalten. Über den F-Droid Store habe
ich lediglich einen anderen Browser und den Nextcloud-Client für Datentransfers
installiert und das klappt wunderbar.&lt;/p&gt;
&lt;p&gt;Ein Use-Case den ich beim Kauf noch nicht im Blick hatte, ist, dass ich über meinen
Arbeitgeber Zugang zur &lt;a href=&#34;https://www.oreilly.com/&#34;&gt;O&amp;rsquo;Reilly Learning Platform&lt;/a&gt;
bekommen habe. Da gibt es nicht nur Bücher zu lesen, sondern auch Video-Kurse
sind dort enthalten. Und das sind nicht nur Bücher von O&amp;rsquo;Reilly, sondern auch
deutsche Verlage wie dpunkt oder mitp sind vertreten, sodass ich da auch mein
Buch entdeckt habe. Die Inhalte lassen sich entweder im Browser lesen oder über
die eigene App, ansonsten bekommt man die Daten da nicht so einfach raus, da es
quasi eher dem Netflix-Modell entspricht. Die App konnte ich mir also auf mein
E-Book-Reader geladen und konnte so schon einige Bücher lesen, die ich auf jeden
Fall nicht im Browser am Bildschirm gelesen hätte. Vertraut mir, ich habs versucht&amp;hellip;&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;tl;dr&lt;/strong&gt;&lt;/em&gt;: Onyx BOOX Note 3 für relativ viel Geld gekauft. Ich lese jetzt deutlich
mehr. Es deckt meine Use-Cases gut ab. Es nervt nicht. Notizen machen per Stift
fühlt sich erstaunlich „echt“ an. Gerne wieder.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Strommessung mit Open Source Tools</title>
      <link>https://svij.org/blog/2021/05/02/strommessung-mit-open-source-tools/</link>
      <pubDate>Sun, 02 May 2021 09:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/05/02/strommessung-mit-open-source-tools/</guid>
      <description>&lt;p&gt;Seit August 2018 besitze ich eine Photovoltaik-Anlage auf dem Dach. Dazu hatte
ich nach einem Jahr &lt;a href=&#34;https://svij.org/blog/2019/08/07/photovoltaik-anlage-auf-dem-dach/&#34;&gt;einen Blogpost&lt;/a&gt;
geschrieben, wo es unter anderem um das Messen vom Strom des ganzen Haushalts
geht.&lt;/p&gt;
&lt;p&gt;Nun wollte ich noch ein wenig mehr Strom im Haushalt messen, allerdings dachte
ich da mehr an einzelne Geräte bzw. an einzelne Steckdosen. Wichtig war für mich
auch, dass ich die Daten kontinuierlich speichern kann und so den Stromverbrauch
über einen gewissen Zeitraum erfassen kann. Außerdem wollte ich selbst Herr über
die Daten sein und hatte auch kein Problem etwas zu frickeln. Da ich vor einem
Jahr etwa dann auf den &lt;a href=&#34;https://blog.koehntopp.info/2020/05/20/gosund-and-tasmota.html&#34;&gt;Blogpost von Kristian
Köhntopp&lt;/a&gt;
gestoßen bin, habe ich das einfach auch ausprobiert, allerdings mit einer
anderen Datenhaltung. In diesem Blogpost gehe ich nicht auf die genauen einzelnen
Schritte ein. Möchte viel mehr die Möglichkeiten auflisten, falls jemand ähnliches
geplant hat.&lt;/p&gt;
&lt;p&gt;Hardware in meinem Fall:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Gosund SP111&lt;/li&gt;
&lt;li&gt;SparkFun Serial Basic Breakout - CH340G DEV-14050&lt;/li&gt;
&lt;li&gt;eine Packung diverser Jumper Kabel&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Aber nun der Reihe nach. Als Hardware kommen bei mir „Gosund SP111“ als „smarte“
Steckdosen zum Einsatz. Die bekommt man im 4er-Pack für 40€ bei einem großen
bekannten Händler. Mit
&lt;a href=&#34;https://github.com/ct-Open-Source/tuya-convert&#34;&gt;tuya-convert&lt;/a&gt; bekommt man dann
kabellos &lt;a href=&#34;https://tasmota.github.io/docs/&#34;&gt;Tasmota&lt;/a&gt; auf die Geräte, womit man
die Open Source Software auf die Geräte spielt und von der Herstellersoftware
befreit. Leider sieht es aktuell so aus, dass sich die aktuelle Geräte sich nicht mehr
mit tuya-convert flashen lassen. Stattdessen muss man die Steckdosen Aufschrauben und
per FTDI Kabel an den Rechner anschließen, um dann Tasmota flashen zu können. Ich
benutzte dazu den oben genannten Serial Basic Breakout. Das musste ich für
zwei der vier Steckdosen auch erledigen, da tuya-convert fehlgeschlagen war. Bei
den aktuell erhältlichen Gosund SP111 v2 Steckdosen lässt sich das allerdings wohl nicht mehr
so einfach öffnen, ohne die Steckdose zu zerstören.&lt;/p&gt;
&lt;p&gt;Generell war das Aufschrauben auch eher ätzend und sehr frickelig, da man an
die Kontakte nicht so einfach drankommt. Eine Anleitung wie die Verkabelung
aussehen kann, findet sich &lt;a href=&#34;https://www.fh19.de/smart-home/tasmota/gosund-sp111-mit-tasmota-flashen/&#34;&gt;in diesem
Blogpost&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Nach dem Flashen von Tasmota kann über die Web-Oberfläche das Gerät mit dem WLAN
verbunden werden. Anschließend kann das Gerät, ebenfalls über die Web-Oberfläche,
konfiguriert werden. Die genauen Konfigurationsdetails finden sich ebenfalls
im &lt;a href=&#34;https://blog.koehntopp.info/2020/05/20/gosund-and-tasmota.html&#34;&gt;Blogpost von Kristian Köhntopp&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Bei mir sieht allerdings das Software-Setup für die Datenhaltung allerdings etwas anders aus.&lt;/p&gt;
&lt;p&gt;Software-Setup:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;MQTT Server (&lt;a href=&#34;https://mosquitto.org/&#34;&gt;mosquitto&lt;/a&gt;)&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://prometheus.io&#34;&gt;Prometheus&lt;/a&gt; Server für das Monitoring mit Datenhaltung&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/hikhvar/mqtt2prometheus&#34;&gt;mqtt2prometheus&lt;/a&gt; um die MQTT Daten für Prometheus verfügbar zu machen&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://grafana.com&#34;&gt;Grafana&lt;/a&gt; zur Visualisierung&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Wie in meinem &lt;a href=&#34;https://svij.org/blog/2020/06/12/homeserver-setup-in-2020.../&#34;&gt;anderen
Blogpost&lt;/a&gt;
geschrieben, läuft bei mir alles in einem Kubernetes mit k3s auf meinem
Homserver.  Dort läuft entsprechend auch die oben genannte Software. Wie zuvor
erwähnt, geh ich nicht auf die einzelnen Konfigurationsoptionen ran. Dazu am
besten die Dokumentationen der einzelnen Tools zur Rate ziehen. Letztendlich
sieht es so aus, dass die Steckdosen die Daten per MQTT an den MQTT Server
schicken und ich mit mqtt2prometheus die Daten entgegennehme und es für
Prometheus bereitstelle. Der Prometheus Server scrapet sich dann die Daten von
dem Dienst. Theoretisch kann ich die Steckdosen auch über Home-Assistant steuern,
um diese etwa zeitgesteuert an- oder auszuschalten. Da ich das allerdings
nicht brauche, habe ich das auch nicht konfiguriert.&lt;/p&gt;
&lt;p&gt;Das aktuelle Setup fahre ich erst wenige Wochen. Zuvor hatte ich eigenes
Scripting im Einsatz gehabt, wo ich die Daten per HTTP von den Steckdosen abgegriffen
habe und in eine InfluxDB gespeichert habe. Davon bin ich abgerückt, weil ich
die Handhabung von verhältnismäßig temporären Daten über Prometheus einfacher
zu verwalten finde und das über MQTT eh besser lösbar ist.&lt;/p&gt;
&lt;p&gt;Die Steckdosen kommen bei mir an vier Stellen zum Einsatz:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;an meinem Arbeitsplatz wo der Laptop, Bildschirm und sonstige Hardware hängt&lt;/li&gt;
&lt;li&gt;an meiner Netzwerkecke, wo mein Server, Switch, WLAN AP, Telefon, Router, Raspberry Pi und sonstige Hardware hängt&lt;/li&gt;
&lt;li&gt;in der Küche, wo im Wesentlichen ein Fernseher und ein paar kleinere Haushaltsgeräte hängen&lt;/li&gt;
&lt;li&gt;im Wohnzimmer, wo der Fernseher mit Receivern, WLAN AP und sonstige TV-Hardware hängt&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Das ganze Gefrickel habe ich ja aus zwei Gründen gemacht: Ich wollte einmal
ein wenig mit Hardware frickeln und mich mit mehr Tools und Protokollen auseinandersetzen.
Dinge wie MQTT, Tasmota und auch ein wenig mehr mit Prometheus spielen war jedenfalls
auch mal interessant. Der zweite Grund war auch den Stromverbrauch überwachen
zu können.&lt;/p&gt;
&lt;p&gt;Dabei fielen mir genau zwei interessante Dinge auf, die ich hier eingehen werde.
Die ist zum einen der Stromverbrauch am Fernseher und zum anderen (vermutlich) Amoklaufende
Prozesse am Server.&lt;/p&gt;
&lt;p&gt;Zunächst zum Fernseher. Der Graph der letzten 24 Stunden sieht so aus:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Stromverbrauch im Wohnzimmer&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/strom_livingroom.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Was fällt auf: Ja, der Fernseher läuft hier ständig, aber da bin ich nicht Schuld und das ist hier auch nicht das Thema.
Spannender ist es eher zu sehen, dass der Fernseher beim Ausschalten zunächst nicht
direkt in das Standby geht, sondern noch mit knapp 20W relativ viel Strom zieht,
bevor es dann wirklich in den Standby geht. Die 80W in Betrieb sind übrigens
im Stromsparmodus der für die meisten Fälle bei uns völlig in Ordnung ist. Vor meinen
Experimenten lief es nicht im Stromsparmodus, das führte zu locker 50% höheren
Stromverbrauch, die ich vorher gar nicht betrachtet hatte.&lt;/p&gt;
&lt;p&gt;Spannend war es allerdings diese Woche den Stromverbrauch an meiner Netzwerkecke
zu betrachten, wo der Hauptstromabnehmer mein Homeserver ist. Hier ist der
Screenshot von den letzten 7 Tagen:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Stromverbrauch in der Netzwerkecke&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/strom_floor.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Der Homeserver zieht natürlich mehr Strom, wenn es unter höherer Last läuft. Warum
es da allerdings alle paar Sekunden bzw. Minuten von normal 75-80W auf 120W
springt, konnte ich mir nicht erklären. Das Debuggen war auch eher nicht zufriedenstellend.
Das System-Monitoring mit Prometheus zeigte keine Amoklaufende Prozesse. Die
Last sah soweit normal aus. Auch ein einfaches &lt;code&gt;htop&lt;/code&gt; zeigte keine Auffälligkeiten
die für einen solchen Stromverbrauch verantwortlich sein könnten.&lt;/p&gt;
&lt;p&gt;Einfache Lösung war dann: Reboot und schauen was passiert. Es hat geholfen.
Warum? Keine Ahnung.&lt;/p&gt;
&lt;p&gt;Wie dem auch sei: Das Rumfrickeln hatte so neben dem Experimentierfaktor so auch
einen kleinen Vorteil beim Stromverbrauch, der allerdings bei mir sowieso im Wesentlichen
von der Photovoltaik-Anlage gedeckt wird.&lt;/p&gt;
&lt;p&gt;Ich gehe übrigens davon aus, dass die Strommessung nicht wirklich genau ist. Wenn
ich den Stromverbrauch aller vier Steckdosen messe und es mit dem Stromverbrauch
des ganzen Hauses mit den Daten des Wechselrichters vergleiche, dann liegt häufig
der Stromverbrauch der vier Steckdosen über denen des ganzen Hauses, was keinen
Sinn ergibt. Aber als grobe Richtlinie ist das für mich in Ordnung.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Firmware vom CalDigit TS3 Plus unter Linux updaten</title>
      <link>https://svij.org/blog/2021/01/03/firmware-vom-caldigit-ts3-plus-unter-linux-updaten/</link>
      <pubDate>Sun, 03 Jan 2021 11:00:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2021/01/03/firmware-vom-caldigit-ts3-plus-unter-linux-updaten/</guid>
      <description>&lt;p&gt;Seit dem letzten Jobwechsel besitze ich am heimischen Arbeitsplatz ein Dell XPS
13 und nutze dazu die Thunderbolt-Dockingstation &lt;a href=&#34;https://www.caldigit.com/ts3-plus/&#34;&gt;„CalDigit TS3
Plus“&lt;/a&gt;. Leider funktionierte sie bisher
nicht so gut wie ich erwarten würde, da diese unter Last häufiger mal
abstürzt und neu startet was vor allem dann passiert, wenn ich in Videocalls
bin.&lt;/p&gt;
&lt;p&gt;Praktisch wäre es ja, wenn es ein Firmware-Update geben würde, die mögliche Fehler
korrigiert. Wenn man nun unter &lt;a href=&#34;https://downloads.caldigit.com/&#34;&gt;downloads.caldigit.com&lt;/a&gt;
schaut, sieht man aber nur Möglichkeiten die Firmware zu aktualisieren für
Windows und macOS. Hab ich leider beides nicht.&lt;/p&gt;
&lt;p&gt;Auch wenn CalDigit keinen offiziellen Update-Mechanismus unter Linux anbietet,
ist dies trotzdem möglich. Denn es lässt sich durch den &lt;a href=&#34;https://fwupd.org/&#34;&gt;fwupdmgr&lt;/a&gt;
aktualisieren.&lt;/p&gt;
&lt;p&gt;&lt;code&gt;fwupdmgr&lt;/code&gt; ist ein Tool, um die Firmware von einzelnen Hardware-Komponenten des
Rechners unter Linux zu aktualisieren. Bei meinen privaten und dienstlichen
Laptops waren unabhängig von der Dockingstation einige
Firmware-Aktualisierungen verfügbar.  Bei mir sieht das aktuell wie folgt aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo fwupdmgr upgrade
Devices with no available firmware updates: 
    • TS3 Plus
    • Integrated Webcam HD
    • SSDPEMKF512G8 NVMe INTEL 512GB
    • Touchpad
    • UEFI dbx
Devices with the latest available firmware version:
    • System Firmware
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie man sieht, wird mein Dock „TS3 Plus“ zwar aufgelistet, aber es findet automatisiert
keine Updates.&lt;/p&gt;
&lt;p&gt;Aufgelistet werden können die Devices mit &lt;code&gt;fwupdtool&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo fwupdtool get-devices
Laden …                  [***************************************]
XPS 13 9300
│
├─TS3 Plus:
│     Device ID:          8c35acb4a72f912a0d0ccf6c27bb9eb2b866b02c
│     Current version:    35.00
│     Vendor:             CalDigit, Inc. (TBT:0x003D)
│     GUIDs:              22a019cc-64d4-592b-a5ea-259176b330cd ← THUNDERBOLT\VEN_003D&amp;amp;DEV_0011&amp;amp;REV_00
│                         7c778112-7403-5f54-aef8-2f4f4f50ce2f ← THUNDERBOLT\VEN_003D&amp;amp;DEV_0011
│                         4b455155-82b1-5d27-8093-70163de758c2 ← TBT-003d0011
│     Device Flags:       • Updatable
│                         • System requires external power source
│                         • Device stages updates
│   
[…]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Die Ausgabe erfolgt hier verkürzt. Die Dockingstation hat zurzeit die Firmware-Version
35 installiert. CalDigit bietet aber Version 44 an.&lt;/p&gt;
&lt;p&gt;Im konkreten Fall kann unter
&lt;a href=&#34;https://downloads.caldigit.com/&#34;&gt;downloads.caldigit.com&lt;/a&gt; der Windows Firmware
Updater heruntergeladen werden. In dem ZIP-File befinden sich im &lt;code&gt;TS3-Plus&lt;/code&gt;
Ordner die einzelnen vorhandenen Firmware-Versionen. Hier wird
&lt;code&gt;CalDigit_TS3_Plus_44.01.bin&lt;/code&gt; benötigt.&lt;/p&gt;
&lt;p&gt;Das Update lässt sich nun über &lt;code&gt;fwupdmgr&lt;/code&gt; installieren:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo fwupdtool install-blob &amp;lt;Firmware Blob&amp;gt; &amp;lt;TS3 Plus Device ID&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In meinem konkreten Fall also mit der Device-ID, die man über &lt;code&gt;fwupdtool get-devices&lt;/code&gt; abrufen kann:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ fwupdtool install-blob CalDigit_TS3_Plus_44.01.bin 8c35acb4a72f912a0d0ccf6c27bb9eb2b866b02c
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Und das war es dann auch schon. Mit einem erneuten Prüfen mit &lt;code&gt;fwupdtool get-devices&lt;/code&gt; wird nun die aktuelle Version angezeigt. Ob das nun meine Probleme
gefixt hat, kann ich hingegen noch nicht sagen. Dafür ist das Update erst
seit paar Minuten installiert.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Neuer Podcast: TILpod</title>
      <link>https://svij.org/blog/2020/12/04/neuer-podcast-tilpod/</link>
      <pubDate>Fri, 04 Dec 2020 10:00:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2020/12/04/neuer-podcast-tilpod/</guid>
      <description>&lt;p&gt;Wir sind mittlerweile im Jahr 2020 angekommen. Podcasts haben sich mehr oder weniger
durchgesetzt und sehr viele Leute hören nicht nur Podcasts, sondern produzieren
auch selbst welche. Vor allem im Tech-Bereich gibts es gefühlt schon fast mehr
als genug&amp;hellip;&lt;/p&gt;
&lt;p&gt;Nichtsdestotrotz – oder gerade deswegen? – dachten sich &lt;a href=&#34;https://dirk.deimeke.ruhr/&#34;&gt;Dirk Deimeke&lt;/a&gt;
und ich: Es wird Zeit, dass wir auch mal einen Podcast starten. Den Gedanken
und die Pläne dazu hatten wir eigentlich schon vor zwei Jahren. Aber aus diversen
Gründen wurde daraus erstmal nichts und wir haben es aufgeschoben. Jetzt ist
aber endlich so weit.&lt;/p&gt;
&lt;p&gt;Mittlerweile haben wir auch schon die nullte und die erste Folge
veröffentlicht. In der nullten Episode erzählen wir von unseren Plänen für den
Podcast. Darunter was das Konzept des Podcasts ist und welche Themen wir behandeln
wollen. Außerdem gibt es einen Rückblick wie und wann Dirk und ich uns kennen gelernt haben.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Spoiler&lt;/em&gt;: In diesem Podcast geht es nicht (ausschließlich) um Open Source, sondern vor allem um Tech, aber
auch um Produktivitäts- und IT-Karriere-Themen. Es wird also hoffentlich ein gesunder
Mix aus den verschiedenen Themen sein.&lt;/p&gt;
&lt;p&gt;Die erste reguläre Episode behandelt das Thema „GitOps“ und „Keine Zeit haben“.
Wie ihr aus dem Titel dieses Blogposts erkennen könnt, lautet der Name des
Podcasts „TILpod“ und dieser ist unter &lt;a href=&#34;https://tilpod.net/&#34;&gt;TILpod.net&lt;/a&gt;
erreichbar. „TIL“ steht dabei für „Today I learned“, es geht also um Themen die
neu für uns beide waren.&lt;/p&gt;
&lt;p&gt;Bevorzugt lässt sich der Podcast natürlich überall da hören, wo es Podcasts
gibt. Die nächste, und somit zweite Episode, erscheint am 1. Januar 2021. Wir
peilen also mindestens ein monatliches Release an. Je nach Lust und Laune kann
da durchaus noch eine zusätzliche Folge pro Monat entstehen.&lt;/p&gt;
&lt;p&gt;Hört gerne rein! Und sehr cool wäre es, wenn ihr uns fleißig Feedback da lässt.
Für den Beginn müssen wir uns wohl erstmal ein wenig einspielen, bis es dann
hoffentlich über die Zeit besser wird – sowohl inhaltlich als auch von der
Technik.&lt;/p&gt;
&lt;h3 id=&#34;links&#34;&gt;Links&lt;/h3&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://tilpod.net/episode/wir-stellen-uns-vor&#34;&gt;TIL000 – Wir stellen uns vor!&lt;/a&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://tilpod.net/episode/til001-keine-zeit-fuer-gitops&#34;&gt;TIL001 – Keine Zeit für GitOps&lt;/a&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Canon-DSLR als Webcam auf Linux-Systemen verwenden</title>
      <link>https://svij.org/blog/2020/11/22/canon-dslr-als-webcam-auf-linux-systemen-verwenden/</link>
      <pubDate>Sun, 22 Nov 2020 15:50:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2020/11/22/canon-dslr-als-webcam-auf-linux-systemen-verwenden/</guid>
      <description>&lt;p&gt;Ganz unabhängig von der aktuellen Weltlage arbeite ich mittlerweile seit April
2020 in einem All-Remote-Job. Was da jeder braucht, ist eine Webcam. Ich wollte
eigentlich zu Beginn des Jobs eine neue Kamera kaufen. Blöd nur, dass die überall ausverkauft
waren und wenn sie lieferbar waren, dann erst Monate später zu Wucherpreisen.&lt;/p&gt;
&lt;p&gt;Für mich musste also kurzfristig eine Alternative her, die sich auch mittelfristig
durchgesetzt hat. Die im Laptop verbaute Webcam ist leider ziemlich unbrauchbar.&lt;/p&gt;
&lt;p&gt;Meine Alternative ist die Nutzung meiner DSLR, die ich eigentlich zum
Fotografieren besitze. Konkret besitze ich eine Canon EOS 700D. Diese Anleitung
hier dokumentiert wie man diese Kamera als Webcam unter Linux zum Laufen
bringt. Leider ist das nicht ganz so einfach und hat ein paar Einschränkungen,
aber dazu gleich mehr.&lt;/p&gt;
&lt;p&gt;Die Kamera habe ich per Mini-USB an meinen Rechner angeschlossen. Zusätzlich wird
noch eine dauerhafte Stromzufuhr gebraucht. In diversen Online-Shops existieren
Batterie-Adapter, die man per USB mit Strom füttern kann. Dieses Teil kostet
so knapp 20 bis 30 Euro.&lt;/p&gt;
&lt;p&gt;Auf der Seite der Software werden prinzipiell drei verschiedene Anwendungen
gebraucht. Die Paketnamen beziehen sich auf ArchLinux, bei anderen Distributionen
sind die Paketnamen aber ähnlich.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;code&gt;gphoto2&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;gstreamer&lt;/code&gt; und &lt;code&gt;gst-plugins-bad&lt;/code&gt;&lt;/li&gt;
&lt;li&gt;&lt;code&gt;v4l2loopback-dkms&lt;/code&gt;&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Um genau zu sein, wird &lt;code&gt;gphoto2&lt;/code&gt; gebraucht, um das Kamerabild abzugreifen. Das
muss dann an &lt;code&gt;gstreamer&lt;/code&gt; gepipet werden, was den Videoinhalt dann in ein Video4Linux2
Loopback-Sink schickt. Anschließend ist die Kamera dann als Webcam verfügbar. Aber
zunächst der Reihe nach.&lt;/p&gt;
&lt;p&gt;Nachdem man sich die oben genannten Pakete installiert hat, wird durch die
Installation von &lt;code&gt;v4l2loopback-dkms&lt;/code&gt; ein Kernel-Modul kompiliert. Dies wird
benötigt, damit man V4L2 Loopback Devices nutzen kann. Dies muss anschließend
auch noch geladen werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo modprobe v4l2loopback devices=1 video_nr=10 card_label=&amp;quot;Canon 700D&amp;quot; exclusive_caps=1
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;An dieser Stelle habe ich nicht nur das reine Modul geladen, sondern habe noch ein
paar Optionen mitgegeben. &lt;code&gt;devices&lt;/code&gt; gibt lediglich an, dass es sich um ein einzelnes Gerät
handelt. Mit &lt;code&gt;video_nr=10&lt;/code&gt; gebe ich an, dass das Gerät unter &lt;code&gt;/dev/video10&lt;/code&gt;
im System verfügbar ist. Mit &lt;code&gt;card_label&lt;/code&gt; gebe ich hingegen schlicht den Namen
an. Wichtig ist noch der Parameter &lt;code&gt;exclusive_caps=1&lt;/code&gt;: Ohne diesen Parameter
erkennt der Chrome die Kamera nicht als Webcam. Warum das so ist, hab ich nicht
ganz verstanden, ist mir aber egal, solange es funktioniert. Im Firefox und in
Zoom funktioniert das auch ohne diesen Parameter.&lt;/p&gt;
&lt;p&gt;Nachdem also das Kernel-Modul geladen ist, muss ich folgenden Befehl verwenden,
um das Gebastel zum Laufen zu kriegen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ gphoto2 --stdout --capture-movie | gst-launch-1.0 fdsrc ! decodebin3 name=dec ! queue ! videoconvert ! v4l2sink device=/dev/video10
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Ein Nachteil dieser Methode ist, dass &lt;code&gt;gphoto2&lt;/code&gt; von der Kamera per USB nur das
Preview-Bild holt und es dem Rechner rüberreicht. Das Preview-Bild ist das Bild,
was auch auf dem eingebauten Display dargestellt wird. Das heißt in meinem Fall,
dass das kein HD-Bild ist, sondern nur eine Auflösung von 960x640 hat. Für den
Einsatz als Webcam ist das allerdings nicht weiter schlimm, da das Bild immer
noch besser ist als bei einer Standard-Full-HD-Webcam. Meistens findet dann
sowieso noch ein Herunterrechnen des Bildes statt.&lt;/p&gt;
&lt;p&gt;Eine Alternative zu dieser Methode wäre die Nutzung einer HDMI-Capture-Card
die das Signal vom HDMI-Ausgang in voller Auflösung abgreift. Da gescheite
HDMI-Capture-Cards über 100 € kosten, hab ich getrost darauf verzichtet.&lt;/p&gt;
&lt;p&gt;Um meinen Workflow ein wenig zu vereinfachen, lade ich das Kernel-Modul
beim jeden Reboot automatisch und hab einen Alias gesetzt, um den langen Befehl
schnell aufrufen zu müssen. Einfaches Plug-and-Play ist das nicht, komfortabel
auch nicht. Aber es war eine einfache Lösung um den Kauf einer überteuerten
und nicht-lieferbaren Webcam zu umgehen, da der Rest der Hardware schon vorhanden
war. In der Dokumentation von gphoto auf &lt;a href=&#34;http://www.gphoto.org/doc/remote/&#34;&gt;gphoto.org&lt;/a&gt;
sind alle Kamera-Modelle aufgelistet, die unterstützt werden.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Homeserver Setup in 2020...</title>
      <link>https://svij.org/blog/2020/06/12/homeserver-setup-in-2020.../</link>
      <pubDate>Fri, 12 Jun 2020 07:40:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2020/06/12/homeserver-setup-in-2020.../</guid>
      <description>&lt;p&gt;Dieses Blog nutze ich leider viel zu selten, um mein eigenes Hardware- und
Software-Setup zu dokumentieren. Manchmal tue ich das zum Glück schon, sodass
ich im Nachhinein dann doch hin und wieder mal nachlesen kann, wie ich das
ein oder andere früher mal gelöst habe.&lt;/p&gt;
&lt;p&gt;Jetzt ist es jedenfalls wieder an der Zeit ein Update für mein Homeserver
zu liefern. Wie auch in den letzten Jahren diente das Frickeln an meinem Homeserver zwei Zielen:&lt;/p&gt;
&lt;ol&gt;
&lt;li&gt;Ich will was lernen.&lt;/li&gt;
&lt;li&gt;Es sollen ein paar Dienste betrieben werden.&lt;/li&gt;
&lt;/ol&gt;
&lt;p&gt;Prinzipiell sollten zwar die Dienste funktionieren, aber im Vordergrund steht
auch neue Technologien und Tools auszuprobieren, um was Neues zu lernen.&lt;/p&gt;
&lt;h1 id=&#34;früher&#34;&gt;Früher™&lt;/h1&gt;
&lt;p&gt;Vor knapp &lt;a href=&#34;https://svij.org/blog/2014/07/15/homeserver-setup/&#34;&gt;sechs Jahren&lt;/a&gt;
ersetzte ich meinen Raspberry Pi durch „richtige“ Hardware. Damals allerdings
auch nur 4GB RAM mit einem Board mit einer Atom CPU. Damit geriet ich schnell
an meine Grenzen, sodass das ganze wenig Spaß gemacht hat. Damals lief darauf
ein ArchLinux und diente hauptsächlich als NAS.&lt;/p&gt;
&lt;p&gt;2016 &lt;a href=&#34;https://svij.org/blog/2016/04/24/homeserver-migration-auf-ubuntu-1604/&#34;&gt;migrierte ich von ArchLinux auf Ubuntu 16.04&lt;/a&gt;.
Dann lief schon mit ownCloud ein bisschen mehr als nur ein Fileserver und mit
mehreren LXC/LXD Containern. Später im Jahr 2016 ersetzte ich die Hardware und
schaffte mir ein Dell PowerEdge T20 mit einer Quad-Code Xeon CPU und 32GB RAM
an. Die Hardware läuft auch noch heute und hat noch genügend Leistung.&lt;/p&gt;
&lt;p&gt;In der Zwischenzeit experimentierte ich vor allem Software aus der „Cloud Native“ Welt herum.&lt;/p&gt;
&lt;h1 id=&#34;heute&#34;&gt;Heute&lt;/h1&gt;
&lt;p&gt;Heute läuft der Server mit Ubuntu 20.04. Darauf laufen keine LXC/LXD Container mehr.
Stattdessen läuft jetzt Kubernetes darauf. Zu Beginn nutzte ich für die Installation
von Kubernetes &lt;a href=&#34;https://github.com/kubernetes-sigs/kubespray&#34;&gt;Kubespray&lt;/a&gt; ein, das
Standard-Kubernetes war allerdings deutlich zu fett. Größtes Manko war, dass
das &lt;code&gt;etcd&lt;/code&gt; verdammt viel auf die SSD geschrieben hat und ich regelmäßig bei
jedem Upgrade das Setup kaputt gespielt habe. Für den Privatgebrauch ergab das
so daher keinen Sinn.&lt;/p&gt;
&lt;p&gt;Mittlerweile setze ich auf das vergleichsweise schlanke
&lt;a href=&#34;https://k3s.io/&#34;&gt;k3s.io&lt;/a&gt;. Das braucht im Heimbetrieb deutlich weniger Leistung
und erledigt trotzdem das, was ich brauche. Statt etcd setzt es auf sqlite und
statt Docker auf containerd.&lt;/p&gt;
&lt;p&gt;Die Kubernetes Manifeste verwalte ich ausschließlich mit „dem GitOps Operator“
&lt;a href=&#34;https://fluxcd.io/&#34;&gt;fluxcd&lt;/a&gt;. Wesentlicher Vorteil ist, dass der Zustand des
Clusters in einem Git-Repository definiert ist und eine vollständige Neuinstallation
innerhalb weniger Minuten durchgeführt werden kann. Im Gegensatz
zu Ansible etwa, gebe ich hier explizit meinen Zielzustand an und eben keine
Abfolge von Anweisungen. Die meisten Anwendungen sind über Helm-Charts installiert.
Einige wenige sind ganz normal als Deployment YAML geschrieben. &lt;code&gt;kubectl&lt;/code&gt;
rufe ich daher nur zum Testen manuell auf. In der Regel mache ich daher einfach
Commits in das Repository und pushe es auf mein GitLab-Repository. fluxcd kümmert
sich dann darum, es auf dem Cluster auszurollen. Ziemlich angenehm.&lt;/p&gt;
&lt;p&gt;Nicht zu vernachlässigen ist bei diesem Setup allerdings, dass die Lernkurve
von Kubernetes verdammt steil ist. Wenn man Zeit und Lust hat, kann man das gut
und gerne so umsetzen. Wirklich sinnvoll im Heimgebrauch ist es für meinen
Anwendungsfall eigentlich nicht, da ich kaum die Skalierungsmechanismen von Kubernetes
brauche und die Komplexität von Kubernetes nicht zu unterschätzen ist. Die
Handhabung ist, sobald man sich mit Kubernetes angefreundet hat, für mich
jedenfalls deutlich angenehmer, als vorher, wo ich Ansible Rollen und Playbooks
geschrieben habe, die auch sehr viel Zeit in Anspruch genommen haben.&lt;/p&gt;
&lt;h1 id=&#34;anwendungen&#34;&gt;Anwendungen&lt;/h1&gt;
&lt;p&gt;Folgende Anwendungen laufen mittlerweile auf meinem Kubernetes-Cluster:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://nextcloud.com/&#34;&gt;Nextcloud&lt;/a&gt; für Kalender, Kontakte und Dateisynchronisation&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://github.com/dani-garcia/bitwarden_rs&#34;&gt;Bitwarden&lt;/a&gt; als Passwortmanager&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://prometheus.io/&#34;&gt;Prometheus&lt;/a&gt; für das Monitoring&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://grafana.com&#34;&gt;Grafana&lt;/a&gt; für die Visualisierung der Daten aus Prometheus, Influx und PostgreSQL&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://about.gitlab.com&#34;&gt;GitLab&lt;/a&gt; für Git-Repositorys&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://ui.com&#34;&gt;Unifi&lt;/a&gt; Controller für meine Unifi APs&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://syncthing.net&#34;&gt;Syncthing&lt;/a&gt; für das Synchronisieren von Backups zu einer Offsite-Stelle&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://rclone.org&#34;&gt;rclone&lt;/a&gt; als Cronjob für das Hochladen von Backups „in die Cloud“&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://gitlab.com/svij/kostal-dataexporter&#34;&gt;Dataexporter der Photovoltaik-Anlage&lt;/a&gt;, der die Daten in eine Influx und PostgreSQL Datenbank schreibt&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.influxdata.com/&#34;&gt;Influxdb&lt;/a&gt; für die Daten der PV-Anlage, sowie Stromverbrauch und Temperatur-Sensoren&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.postgresql.org/&#34;&gt;PostgreSQL&lt;/a&gt; für Nextcloud, Kostal Datenhaltung und GitLab&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://www.plex.tv/&#34;&gt;Plex&lt;/a&gt; für Multimedia-Daten&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://min.io/&#34;&gt;minio&lt;/a&gt; als S3-kompatibles Object-Storage-Backend für GitLab&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://traefik.io&#34;&gt;traefik&lt;/a&gt; als Reverse Proxy&lt;/li&gt;
&lt;li&gt;Bald: &lt;a href=&#34;https://www.home-assistant.io/&#34;&gt;Home-Assistant&lt;/a&gt; für Smart-Home&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Fast alles installiere ich über fertige Helm-Charts. Einzig zwei Datensammler-Skripte
für smarte Stromsteckdosen und für die PV-Anlage erfolgen über eigene, selbst
gebaute, Container. Diese baue ich sehr einfach über die &lt;a href=&#34;https://docs.gitlab.com/ee/topics/autodevops/&#34;&gt;Auto DevOps&lt;/a&gt;
Funktionalität von GitLab auf GitLab.com.&lt;/p&gt;
&lt;p&gt;Außerhalb von Kubernetes läuft sonst nur noch &lt;a href=&#34;https://svij.org/blog/2016/11/12/verteiltes-backup-konzept-mit-borg/&#34;&gt;borgbackup&lt;/a&gt;
und sonst eigentlich nichts mehr. Den Rest habe ich sonst weiterhin mit
Ansible durch automatisiert, allerdings durch den Einsatz von Kubernetes mit fluxcd
in einem deutlich geringerem Umfang.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Skalierbare Container-Infrastrukturen</title>
      <link>https://svij.org/blog/2019/11/25/rezension-skalierbare-container-infrastrukturen/</link>
      <pubDate>Mon, 25 Nov 2019 08:30:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/11/25/rezension-skalierbare-container-infrastrukturen/</guid>
      <description>&lt;p&gt;In dieser Rezension bespreche ich das Buch &lt;a href=&#34;https://www.rheinwerk-verlag.de/skalierbare-container-infrastrukturen_4676/&#34;&gt;„Skarlierbare Container-Infrastrukturen“&lt;/a&gt;
vom Autor Oliver Liebel vom Rheinwerk-Verlag.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Hinweis:&lt;/strong&gt; Der Rheinwerk-Verlag stellte mir für die Rezension ein Rezensionsexmplar
frei zur Verfügung.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Viel! Sehr viel sogar. Das Buch umfasst insgesamt 1380 Seiten, ist nicht nur
von außen betrachtet ein echt umfangreiches Buch. Es unterteilt sich in 5 Teile
mit insgesamt 25 Kapiteln.&lt;/p&gt;
&lt;p&gt;Der Autor beginnt den ersten Teil „Brave New World?“ mit dem allgemeinen
Einstieg in das Thema der Container: Was ist es und wofür braucht man es?
Er beantwortet zudem die Frage, ob es wirklich alles so einfach ist, wie behauptet wird.&lt;/p&gt;
&lt;p&gt;Die Grundlagen werden im zweiten Teil „Single-Node Container-Systeme“ vermittelt.
Hier geht es vor allem, aber nicht nur, um Docker. So wird ein Einstieg gegeben
und die grundlegenden Konzepte und Kommandos an Hand von Beispielen erläutert.&lt;/p&gt;
&lt;p&gt;Teil 3 „Skaliarbare Container-Cluster und Container-Orchestrierung“ behandelt
im Wesentlichen Kubernetes und etcd. Dies ist zudem auch der umfangreichste
Teil: Es macht mit 672 Seiten knapp die Hälfte des Buches aus. Kein Wunder: Kubernetes
ist sehr komplex und auf die Einzelheiten wird näher eingegangen. Darunter etwa
auch, wie man Kubernetes ohne Docker betreibt.&lt;/p&gt;
&lt;p&gt;Im vierten Teil „High-Level-Orchestrierungstools für Container-Infrastrukturen
(on Premise und in der Cloud)“ setzt auf den dritten Teil auf und behandelt
im wesentlich OpenShift, was die Kubernetes-Distribution von Red Hat ist.&lt;/p&gt;
&lt;p&gt;Der fünfte und letzter Teil „Software-Defined Storage für verteilte
Container-Infrastrukturen“ befasst sich mit Software-Defined-Storage, darunter
Ceph. Zusätzlich werden noch Checkpunkte für vor den Aufbau von Container-Infrastrukturen
besprochen, sowie ein Ausblick und Fazit zur Container-Welt gegeben.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Meine Gefühle für das Buch sind ein wenig gemischt. Keine Frage: Fachlich ist
das Buch sehr gut. Es ist nicht nur beim Blick auf die Seitenanzahl sehr
umfangreich, sondern auch beim tatsächlichen Inhalt. Wichtig ist, dass an sehr
vielen Stellen erkennbar ist, dass der Autor viele Praxis-Kenntnisse in dem Bereich
besitzt. Das führt dazu, dass an sehr vielen Stellen praxis-relevante Hinweise
gegeben werden, wie gut oder vor allem schlecht etwas funktioniert.&lt;/p&gt;
&lt;p&gt;Und genau der letzte genannte Punkt ist zeitgleich mein größter Kritikpunkt.
Prinzipiell find ich es gar nicht so schlecht, wenn in Büchern „Klartext“
geschrieben wird und die Probleme richtig genannt werden, da nicht alles
so schön einfach ist, wie immer behauptet wird. Mein wesentliches Problem ist
der Ton. An sehr vielen Stellen liest sich die Kritik, etwa wenn etwas nicht
wie angeworben funktioniert, als wenn der Autor &lt;strong&gt;sehr&lt;/strong&gt; frustriert ist.
Stellenweise hatte ich als Leser das Gefühl, dass der Autor seine Frust an
Entscheidungsträgern und einzelnen Design- und Software-Entscheidungen nur im
Buch auslässt.&lt;/p&gt;
&lt;p&gt;Gepaart wird dies durch den hohen Einsatz von Umgangssprache, was meinen Eindruck vom
Buch weiter senkt. Zu Beginn fand ich den Schreibstil ja ganz nett: Die Probleme
und Irrtümer im Umgang mit Container-Infrastrukturen werden klar, deutlich und auch hart
benannt. Auf die Dauer verbreitete sich bei mir das Gefühl, dass immer weiter Frust
abgeladen wird. Zwei Beispiele für zu viel Slang, die sehr oft vorkommen: „Nö“ und
„Würgaround“. „Nö“ wird sogar erschreckend oft in Überschriften von Absätzen
verwendet. „Würgaroung“ (statt Workaround) kenne ich eher nur von alten Forenposts,
wo es heutzutage auch kaum einer mehr verwendet. Meiner Meinung nach ist so ein Slang
in einem professionellen Buch fehl am Platz und macht zumindest bei der Häufigkeit
wie hier, keinen guten Eindruck.&lt;/p&gt;
&lt;p&gt;Unabhängig von der Sprache ist der fachliche Umfang tadellos: Es ist sehr umfangreich
und geht in sehr viele tiefe Eigenschaften, Eigenheiten und auch Probleme im
Umgang mit den Technologien ein. Der Preis mit 79,90 €
ist nicht gering, aber bei dem Umfang durchaus nachvollziehbar. Problematisch
bei dem Themengebiet ist zusätzlich, dass sehr vieles in dem Buch sehr schnell
veraltet. Dafür kann der Autor und der Verlag nichts, da die Welt der Container
sich sehr schnell weiterentwickelt. Das Buch kam in der ersten Auflage im April
2017 und die von mir gelesene zweite Auflage im Oktober 2018 auf dem Markt. Ist also
schon ein Jahr alt. In der Zwischenzeit ist viel passiert, so ist mittlerweile
OpenShift 4 erschienen, was sich schon deutlich vom behandelten OpenShift 3
unterscheidet. Man muss sich also zusätzlich zu dem Buch noch separat auf den
aktuellen Stand der Technik bringen.&lt;/p&gt;
&lt;p&gt;Würde ich das Buch trotzdem empfehlen: Ja! Wer eine sehr gute Einführung in
die Welt der Container möchte, kommt an dieses Buch nicht vorbei. Wichtig ist
allerdings noch hervorzuheben, dass (sehr) gute Linux- und Netzwerk-Kenntnisse
unabdingbar ist. Grundlagen zu diesen Themen werden nicht thematisiert, die muss man
sich selbst aneignen. Wer sich dem Thema widmen sollte und nur grundlegende
Kenntnisse mitbringt, wird es schwierig haben – und das ganz unabhängig von der
verwendeten Lektüre.&lt;/p&gt;
&lt;h3 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; &lt;a href=&#34;https://www.rheinwerk-verlag.de/skalierbare-container-infrastrukturen_4676/&#34;&gt;Skalierbare Container-Infrastrukturen&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Oliver Liebel&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt; Rheinwerk&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt; 1380 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt; 978-3-8362-6385-6&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 79,90 €&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>git subtree: Eine Alternative für git submodule?</title>
      <link>https://svij.org/blog/2019/11/10/git-subtree-eine-alternative-fur-git-submodule/</link>
      <pubDate>Sun, 10 Nov 2019 16:45:00 +0100</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/11/10/git-subtree-eine-alternative-fur-git-submodule/</guid>
      <description>&lt;p&gt;Für Software-Projekte werden häufiger mehrere Repositorys benötigt, in denen
getrennt und zusammen voneinander entwickelt wird. Dies trifft
insbesondere dann zu, wenn etwa eine Bibliothek in mehreren Projekten benötigt
wird, aber unabhängig voneinander in den anderen Projekten genutzt wird. Hier
ergibt es Sinn, ein separates Git-Repository für die Bibliothek zu nutzen und dieses
in die anderen Projekte einzubinden.&lt;/p&gt;
&lt;h1 id=&#34;git-submodule&#34;&gt;git submodule&lt;/h1&gt;
&lt;p&gt;Eine Möglichkeit solche Unter-Repositorys einzubinden ist die Nutzung von
&lt;code&gt;git submodule&lt;/code&gt;. Diejenigen die es schon nutzen, dürften wissen, dass die Arbeit
mit Submodulen häufig sehr anstrengend und mühselig ist – und das aus verschiedenen
UX-Gründen.&lt;/p&gt;
&lt;p&gt;Submodule müssen in einem Git-Repository mit &lt;code&gt;git submodule add $REPO_URL&lt;/code&gt; zunächst
hinzugefügt werden. Dadurch wird im entsprechenden Haupt-Repository die Datei &lt;code&gt;.gitmodules&lt;/code&gt;
angelegt, die direkt zum Staging-Bereich hinzugefügt wird. Nach einem Commit ist
das Submodule korrekt eingebunden. Wenn ihr das Log anschaut, dann seht ihr das Log des
Submodules nicht. Wenn ihr in das Unterverzeichnis rein wechselt und euch von dort das Log
anschaut, dann seht ihr das Log des Submodule-Repositorys. Sobald ihr nun Commits im Submodule
macht, müsst ihr von dort aus die Commits pushen und zurück in das Haupt-Repository wechseln.
Von dort muss man dann erneut ein Commit tätigen, um das die Änderungen aus dem Submodule
im Haupt-Repository ebenfalls korrekt verwenden zu können. Eine Änderung im Submodule führt also
zu mindestens zwei Commits: ein Commit im Submodule und ein Commit im Haupt-Repository.&lt;/p&gt;
&lt;p&gt;Komplizierter ist das Verhalten, wenn jemand das Haupt-Repository neuklont. Beim Klonen
muss ein rekursiver Clone mit &lt;code&gt;git clone --recursive&lt;/code&gt; notwendig oder ihr klont „normal“
und führt dann &lt;code&gt;git submodule init&lt;/code&gt; in dem jeweiligen Submodule Verzeichnis aus. Wenn ihr nun
noch eine Änderung machen wollt, dann müsst ihr im Submodule-Repository zunächst den richtigen Branch
auschecken. Letzteres ist häufig verwirrend, weil man das überhaupt nicht gewohnt ist. Die übrigen
Schritte, die zuvor erklärt wurden, kommen dann nochmal obendrauf.&lt;/p&gt;
&lt;p&gt;Wer jetzt denkt „Hä?“ oder es ziemlich umständlich findet, denen kann ich jetzt zu Recht sagen:
Stimmt! Angenehm ist was anderes. Ganz allgemein lohnen sich Submodule besonders dann, wenn
die Versionen in Submodulen selten aktualisiert werden müssen und es demnach keine hohe Entwicklungsaktivität
stattfindet.&lt;/p&gt;
&lt;h1 id=&#34;git-subtree&#34;&gt;git subtree&lt;/h1&gt;
&lt;p&gt;Eine Alternative zu &lt;code&gt;git submodule&lt;/code&gt; ist &lt;code&gt;git subtree&lt;/code&gt;. Es ist zwar auch nicht die perfekte
Lösung, bietet aber einige Vor- und Nachteile im Vergleich zu &lt;code&gt;git submodule&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;In produktiven Umgebungen habe ich noch nicht mit &lt;code&gt;git subtree&lt;/code&gt; gearbeitet, sondern habe es
für diesen Blogpost erst angeschaut. In meinem Git-Repository für meinen Blog, den ihr gerade
lest, hatte ich bis gerade eben auch ein Repository als Submodule eingebunden, was dem
Theme der Webseite entspricht.&lt;/p&gt;
&lt;p&gt;Im Folgenden gehe ich direkt mal in die Praxis und zeige, wie &lt;code&gt;git subtree&lt;/code&gt; an einem praktischen Beispiel
verwendet werden kann.&lt;/p&gt;
&lt;p&gt;Zu Beginn muss das Repository als weiteres Remote-Repository hinzugefügt werden. In der Regel
besitzt man Remote-Repositorys &lt;code&gt;origin&lt;/code&gt; und vielleicht &lt;code&gt;upstream&lt;/code&gt;. In dem Fall hat man
zwei Remote-Repositorys, um nach &lt;code&gt;origin&lt;/code&gt; seine eigenen Änderungen pushen zu dürfen (bei einem Fork etwa)
und &lt;code&gt;upstream&lt;/code&gt;, was dem Upstream-Repository des Projektes entspricht.&lt;/p&gt;
&lt;p&gt;Das Remote-Repository muss wie folgt angelegt werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote add -f $REMOTE_NAME $REPOSITORY_URL
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl muss, wie zu sehen ist, mit &lt;code&gt;-f&lt;/code&gt; aufgerufen werden. &lt;code&gt;-f&lt;/code&gt; ist die kurze Form von &lt;code&gt;--force&lt;/code&gt;.
Aber warum &lt;code&gt;--force&lt;/code&gt;? Das Remote-Repository, was als Subtree hinzugefügt werden soll, hat keine
gemeinsame Historie, da die Historie bisher komplett getrennt war. Es ist schlicht kein verwandtes Repository.&lt;/p&gt;
&lt;p&gt;In der Praxis sah es bei mir dann so aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote add -f AllinOne git@git.svij.org:svij/hugo_allinone_theme.git
Aktualisiere AllinOne
warning: keine gemeinsamen Commits
remote: Enumerating objects: 968, done.
remote: Counting objects: 100% (968/968), done.
remote: Compressing objects: 100% (574/574), done.
remote: Total 968 (delta 362), reused 947 (delta 351)
Empfange Objekte: 100% (968/968), 24.54 MiB | 11.15 MiB/s, Fertig.
Löse Unterschiede auf: 100% (362/362), Fertig.
Von git.svij.org:svij/hugo_allinone_theme
* [neuer Branch]    master     -&amp;gt; AllinOne/master
* [neues Tag]       v1.0       -&amp;gt; v1.0
* [neues Tag]       v1.1       -&amp;gt; v1.1
* [neues Tag]       v1.2       -&amp;gt; v1.2
* [neues Tag]       v1.3       -&amp;gt; v1.3
* [neues Tag]       v1.4       -&amp;gt; v1.4
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie ihr sehen könnt, erfolgt eine Warnung, dass es keine gemeinsamen Commits gibt. Davon
abgesehen wird das Remote-Repository wie jedes andere Remote-Repository auch gefetcht, also
die Objekte heruntergeladen. Bis zu diesem Zeitpunkt haben wir noch nichts spezifisches für
&lt;code&gt;git subtree&lt;/code&gt; gemacht, das kommt aber jetzt.&lt;/p&gt;
&lt;p&gt;Das Hinzufügen mit &lt;code&gt;git subtree&lt;/code&gt; benötigt einige Parameter:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git subtree add --prefix $PATH_IN_REPO $REMOTE_NAME $BRANCH --squash
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie ihr seht, ruft man &lt;code&gt;git subtree add&lt;/code&gt; mit dem Parameter &lt;code&gt;--prefix&lt;/code&gt; auf. Hier kann auch die
Kurzform &lt;code&gt;-P&lt;/code&gt; genutzt werden. Der Prefix ist der Pfad im Repository, wo der Subtree landen
soll. Zudem muss noch der Name des zuvor hinzugefügten Remotes angegeben werden, sowie der Branch.
In diesem Fall habe ich auch noch &lt;code&gt;--squash&lt;/code&gt; hinzugefügt, damit die bisherigen Historie des
Subtree-Repositorys nicht im Haupt-Repository landen soll, sondern nur als einzigen Commit
in der Historie der Haupt-Repositorys erscheint.&lt;/p&gt;
&lt;p&gt;In meinem Fall sah das Ganze in der Praxis dann so aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git subtree add --prefix themes/AllinOne AllinOne master --squash
git fetch AllinOne master
Von git.svij.org:svij/hugo_allinone_theme
* branch            master     -&amp;gt; FETCH_HEAD
Added dir &#39;themes/AllinOne&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn wir uns aber nun die Historie ansehen, sehen wir zwei neue Commits:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git log -2 --oneline
e82400c (HEAD -&amp;gt; master) Merge commit &#39;59be897c12c39412755cd93996d85590ef53fdc9&#39; as &#39;themes/AllinOne&#39;
59be897 Squashed &#39;themes/AllinOne/&#39; content from commit 88c7956
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In dem älteren Commit wurde das angesprochene Squashing des Repositorys durchgeführt,
und in dem darauffolgenden Commit ist ein Merge durchgeführt worden. Im konkreten Fall
wurde ein Merge von einem Branch durchgeführt, der &lt;strong&gt;nicht&lt;/strong&gt; denselben Ursprung hat.&lt;/p&gt;
&lt;p&gt;Falls sich im Subtree-Repository etwas unabhängig vom Haupt-Repository verändert, dann
können die Änderungen wie folgt heruntergeladen werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git fetch AllinOne master
Von git.svij.org:svij/hugo_allinone_theme
* branch            master     -&amp;gt; FETCH_HEAD
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Diese sind dann aber noch nicht (!) im Haupt-Repository gemergt. Dazu muss mit folgendem
Befehl durchgeführt werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git subtree pull --prefix themes/AllinOne AllinOne master --squash
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Parameter sind äquivalent zu den vorherigen Befehlen. Auch hier muss man die vielen
Parameter mit angeben.&lt;/p&gt;
&lt;p&gt;Anders sieht es allerdings aus, wenn man einen Commit im Haupt-Repository macht, wo
der Inhalt des Subtree-Repositorys angefasst wird. In meinem Beispiel will ich etwa
das Verzeichnis &lt;code&gt;themes/AllinOne/exampleSite&lt;/code&gt; aus dem Haupt-Repository und dem Subtree-Repository
entfernen. Die ersten Schritte sind soweit ganz normal:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ rm -rf themes/AllinOne/exampleSite
$ git add themes/AllinOne
$ git commit -m &amp;quot;Remove exampleSite from AllinOne&amp;quot;
$ git push origin master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Mit diesem Befehl wurde im Haupt-Repository das Verzeichnis entfernt, ein Commit erstellt
und gepusht. Dass es sich um ein Subtree-Repository handelt, ist von der Handhabung her
nicht zu erkennen.&lt;/p&gt;
&lt;p&gt;Was jetzt noch fehlt, ist das Pushen des Commits in das Subtree-Repository. Das funktioniert
ähnlich wie auch beim Pull:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git subtree push --prefix=themes/AllinOne AllinOne master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man nun in die Historie des Subtree-Repositorys schaut, sieht man genau einen neuen
Commit mit der Commit-Message &lt;code&gt;Remove exampleSite from AllinOne&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Und das war es auch schon. Theoretisch und auch praktisch ist es auch möglich das ganze
ohne das &lt;code&gt;git subtree&lt;/code&gt; Kommando zu erledigen, was die Handhabung der Subtree-Funktion
allerdings nicht erleichtert.&lt;/p&gt;
&lt;h1 id=&#34;fazit&#34;&gt;Fazit&lt;/h1&gt;
&lt;p&gt;Mit &lt;code&gt;git subtree&lt;/code&gt; hat man einige Vor- und Nachteile im Vergleich zu &lt;code&gt;git submodule&lt;/code&gt;. Die
perfekte Lösung ist es auch nicht, da man zwangsläufig ein paar neue Befehle lernen muss
und nicht vergessen darf, damit in beiden Repositorys die Änderungen landen.&lt;/p&gt;
&lt;p&gt;Welche Vorteile hat also &lt;code&gt;git subtree&lt;/code&gt; im Vergleich zu &lt;code&gt;git submodule&lt;/code&gt;?:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Bei bestehenden Repositorys mit Subtree ist kein &lt;code&gt;git clone --recursive&lt;/code&gt; notwendig.&lt;/li&gt;
&lt;li&gt;Der Workflow um Änderungen im Haupt-Repositorys zu veröffentlichen ist vergleichsweise einfach.&lt;/li&gt;
&lt;li&gt;Nutzer von Repositorys mit Subtree müssen nicht wesentlich was Neues lernen.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Die Nachteile sind:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Ein neuer Befehl &lt;code&gt;subtree&lt;/code&gt; mit zahlreichen Parametern wird benötigt.&lt;/li&gt;
&lt;li&gt;Das Veröffentlichen von Änderungen im Subtree-Repository kann vergessen werden.&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Es gibt sicherlich noch den ein oder anderen Vor- und Nachteil in der Praxis, der mir
nicht bekannt ist. Da ich es bisher nicht produktiv eingesetzt habe, kann ich dazu noch
nicht so viel sagen. Es ist jedenfalls auf Anhieb deutlich angenehmer zu nutzen, als
&lt;code&gt;git submodule&lt;/code&gt; und das ist dann ja schon mal etwas.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>git switch und git restore statt git checkout</title>
      <link>https://svij.org/blog/2019/09/07/git-switch-und-git-restore-statt-git-checkout/</link>
      <pubDate>Sat, 07 Sep 2019 09:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/09/07/git-switch-und-git-restore-statt-git-checkout/</guid>
      <description>&lt;p&gt;Mich fragen ja häufiger mal Leute, was sich so in den letzten Git-Versionen
getan hat. Das frage ich mich natürlich auch immer mal wieder und lese jedes
Mal die Release-Notes und finde in der Regel nichts spannendes was mich als
Endnutzer interessiert. Ja, Verbesserungen der Performance und Fehlerkorrekturen
sind gut und wichtig – als „normaler“ Nutzer merkt man davon allerdings recht wenig.&lt;/p&gt;
&lt;p&gt;Interessant ist allerdings die Neuerung in Git Version 2.23, die Mitte August
veröffentlicht wurde. Es gibt nun zwei experimentelle neue Kommandos: &lt;code&gt;git switch&lt;/code&gt;
und &lt;code&gt;git restore&lt;/code&gt;. Beide koexistieren zu dem bisherigen Kommando &lt;code&gt;git checkout&lt;/code&gt;
was den gängigen Git Nutzer bekannt sein sollte. Wie zuvor erwähnt, handelt es
sich um „experimentelle“ Kommandos, das heißt, die Funktion wird zwar bleiben,
die Parameter können sich allerdings noch weiter verändern und sind möglicherweise
noch fehlerbehaftet.&lt;/p&gt;
&lt;p&gt;In diesem Blogpost begutachte ich die beiden neuen Befehle und zeige die Unterschiede
zu dem bisherigen Kommando auf.&lt;/p&gt;
&lt;h3 id=&#34;status-quo&#34;&gt;Status Quo&lt;/h3&gt;
&lt;p&gt;Bevor wir uns die neuen Befehle anschauen lohnt es sich noch einmal aufzufrischen,
wie der Status Quo ist und warum die neuen Befehle praktisch und sinnvoll sind.&lt;/p&gt;
&lt;p&gt;Der Subbefehl &lt;code&gt;checkout&lt;/code&gt; wird vielfältig in Git eingesetzt. Der wohl gängigste Einsatz
ist der Wechsel von einem auf den anderen Branch:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dieser Befehl wechselt vom aktuellen Branch auf den Branch &lt;code&gt;master&lt;/code&gt;. Es ist auch
möglich einen neuen Branch zu erstellen und direkt darauf zu wechseln:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout -b feature/1337
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dieser Befehl nimmt den aktuellen Branch, auf dem man sich gerade befindet, und
legt den Branch namens &lt;code&gt;feature/1337&lt;/code&gt; an und wechselt direkt da hin. Möchte man
einen anderen Branch als Basis nehmen, tippt man den Namen dahinter als weiteren
Parameter ein. Alternativ lässt sich mit &lt;code&gt;git branch feature/1337&lt;/code&gt; ebenfalls ein
Branch anlegen, auf dem man nicht automatisch hin wechselt.&lt;/p&gt;
&lt;p&gt;Checkout als Befehl zum Wechseln und Erzeugen von Branches sollte für die meisten
geübten Git-Nutzern bekannt und gängig sein. Genau so lege ich immer meine Branches
auf der Kommandozeile bisher an.&lt;/p&gt;
&lt;p&gt;Der andere Modus von Checkout ist das Auschecken von Dateien aus anderen Branches,
Revisionen bzw. dem Verwerfen von Änderungen aus dem Staging-Bereich und der Arbeitskopie.
Dies wird durch die Nutzung von doppelten Minuszeichen &lt;code&gt;--&lt;/code&gt; ermöglicht.&lt;/p&gt;
&lt;p&gt;In der bereits versionierten Datei &lt;code&gt;index.html&lt;/code&gt; sind Änderungen
vorhanden, die nicht im Staging-Bereich enthalten sind. Um die Änderungen zu verwerfen,
kann folgender Befehl verwendet werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout -- index.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Somit sind die Änderungen in der Arbeitskopie verworfen und können nicht wiederhergestellt
werden. Der Inhalt der Datei &lt;code&gt;index.html&lt;/code&gt; wurde auf den Stand von HEAD – also dem
aktuell ausgecheckten Commit – zurückgesetzt. Der Befehl kann auch verwendet werden,
um einzelne Dateien aus einem anderen Branch auszuchecken und im aktuellen Projekt
abzulegen.&lt;/p&gt;
&lt;p&gt;Dieser Befehl würde dann wie folgt lauten:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout feature/1337 -- index.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Die Datei &lt;code&gt;index.html&lt;/code&gt; aus dem Branch &lt;code&gt;feature/1337&lt;/code&gt; wird dann von Git im aktuellen
Projektverzeichnis abgelegt. Mit einem &lt;code&gt;git status&lt;/code&gt; wird dann auch aufgelistet, dass sich
die Datei verändert hat. Dies natürlich nur unter der Voraussetzung, dass sich
die Datei in beiden Branches unterscheiden. Statt eines Branches können auch
andere Revisionen angegeben werden. Denn nicht vergessen: ein Branch sind letztendlich
auch nur Zeiger auf einen bestimmten Commit, der stetig aktualisiert wird.&lt;/p&gt;
&lt;h3 id=&#34;status-futurus&#34;&gt;Status Futurus&lt;/h3&gt;
&lt;p&gt;Mit den neuen Kommandos &lt;code&gt;switch&lt;/code&gt; und &lt;code&gt;restore&lt;/code&gt; wird alles besser! Na gut,
zumindest wird deutlich einfacher zu verstehen, was diese tun. Mit beiden
Befehlen werden alte Zöpfe nach und nach abgeschnitten und die Befehle
klarer und besser zu nutzen.&lt;/p&gt;
&lt;p&gt;Git-Nutzer wissen vermutlich, dass viele Befehle nicht so offensichtlich sind und es
nicht unbedingt auf Anhieb nachvollziehbar ist, was welcher Befehl tut. Das gute
Beispiel ist eben &lt;code&gt;git checkout&lt;/code&gt; womit man sowohl Branches wechseln kann, als auch
Dateien aus anderen Revisionen holen kann.&lt;/p&gt;
&lt;h4 id=&#34;git-switch&#34;&gt;git switch&lt;/h4&gt;
&lt;p&gt;Für das Wechseln von Branches gibt es jetzt den Befehl &lt;code&gt;git switch&lt;/code&gt;. Mit diesem
lassen sich ebenfalls neue Branches anlegen. Das Wechseln von einem Branch funktioniert
wie äquivalent:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git switch feature/1337
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Für das Erstellen eines neuen Branches existiert der Parameter &lt;code&gt;-c&lt;/code&gt;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git switch -c feature/1337
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dies ist äquivalent zu &lt;code&gt;git checkout -b feature/1337&lt;/code&gt;. Interessant ist auch der Parameter
&lt;code&gt;-C&lt;/code&gt;, der mit einem großem C geschrieben wird. Dies ist effektiv ein forciertes
Anlegen eines neuen Branches, da der Zielbranch hart überschrieben wird. Hier gilt
es also aufzupassen.&lt;/p&gt;
&lt;h4 id=&#34;git-restore&#34;&gt;git restore&lt;/h4&gt;
&lt;p&gt;Der zweite Befehl ist &lt;code&gt;git restore&lt;/code&gt;. Wie der Name schon verrät, lassen sich
Dateien wiederherstellen.&lt;/p&gt;
&lt;p&gt;Die erste Nutzungsmöglichkeit ist bereits, wenn man eine neue Datei anlegt und
diese zum Staging-Bereich hinzufügt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ echo &amp;quot;Hallo&amp;quot; &amp;gt; hallo.txt
$ git add hallo.txt
$ git status
Auf Branch master
Zum Commit vorgemerkte Änderungen:
  (benutzen Sie &amp;quot;git restore --staged &amp;lt;Datei&amp;gt;...&amp;quot; zum Entfernen aus der Staging-Area)
        neue Datei:     hallo.txt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Git zeigt schon ab der neuen Version 2.23 an, dass man &lt;code&gt;git restore&lt;/code&gt; verwenden
soll und kann. In diesem Fall lässt sich mit dem Befehl die Datei aus dem Staging-Bereich
wieder herausnehmen. Restore lässt sich natürlich auch dafür verwenden eine Datei
aus einem anderen Commit zu holen. Als zusätzlicher Parameter wird &lt;code&gt;--source&lt;/code&gt;
benötigt:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git restore --source feature/1337 index.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dies holt die Datei in das Arbeitsverzeichnis rein. Mit dem zusätzlichen Parameter
&lt;code&gt;--staged&lt;/code&gt; wird die Änderung hingegen direkt in den Staging-Bereich geschoben.&lt;/p&gt;
&lt;p&gt;Sowohl &lt;code&gt;git restore&lt;/code&gt; als auch &lt;code&gt;git switch&lt;/code&gt; besitzen ein paar mehr Parameter.
Meiner Meinung nach sind beide sinnvolle Ergänzungen und machen die Nutzung von
Git deutlich angenehmer. Schwierig ist für den geübten Git-Nutzer nur sich die
neuen Befehle einzuprägen. Bei mir sind die bisherigen Befehle schon länger in
Fleisch und Blut übergangen, sodass ich jetzt erstmal umlernen muss.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Photovoltaik-Anlage auf dem Dach</title>
      <link>https://svij.org/blog/2019/08/07/photovoltaik-anlage-auf-dem-dach/</link>
      <pubDate>Wed, 07 Aug 2019 20:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/08/07/photovoltaik-anlage-auf-dem-dach/</guid>
      <description>&lt;p&gt;Hier mal ein thematisch etwas anderer Blogpost. Vor etwas über einem Jahr ließ
ich mir eine Photovoltaik-Anlage auf dem Dach des Hauses montieren. Einige Tage
nach der Montage ging die Anlage auch an das Stromnetz. Das ist heute auf dem
Tag genau ein Jahr her. In diesem Blogpost zeige ich ein wenig, wie mäßig die
Software ist, wie man selbst Herr über die Daten wird und wie weit die Schätzungen
vom Ertrag von der Realität abweichen.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;PV-Anlage auf dem Dach…&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/pv-anlage.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Die Photovoltaik-Anlage besteht aus 20 Modulen à 335W. Es hat somit eine
Peak-Leistung von 6700 Wh. Theoretisch sollte also keine höhere Peak-Leistung
bei Idealbedingungen möglich sein, in der Realität sah ich ein paar mal Peak-Leistungen,
die darüber lagen.&lt;/p&gt;
&lt;h2 id=&#34;smarter-wechselrichter&#34;&gt;(Smarter) Wechselrichter&lt;/h2&gt;
&lt;p&gt;Neben den Modulen, Gestellen, Kabeln und anderen Kleinigkeiten, besteht so eine
Photovoltaik-Anlage noch aus einem Wechselrichter, der den Gleichstrom in
Wechselstrom umwandelt. Konkret besitze ich einen Kostal PIKO 7.0. Viele der
neueren Wechselrichter sind „smart“. Sie besitzen eine LAN-Buchse und kommen
also mit Web-Interface und App daher, mit diversen Vor- und Nachteilen, was die
Daten angeht, da man diese optional aus der Hand geben kann, was ich tue.&lt;/p&gt;
&lt;p&gt;Die Qualität der Software ist allerdings optimierungsbedürftig. Der Wechselrichter
erfasst einiges an Daten. Das umfasst unter anderem den aktuellen Stromverbrauch des Hauses,
die Generatorleistung (Ertrag) der PV-Module, eine Eigenverbrauchsquote oder
ein Einspeisung des Stroms in das öffentliche Netz. Der Wechselrichter sammelt
diese Daten für ein paar Stunden und lädt sie in (un)regelmäßigen Abständen innerhalb eines Tages auf
den Server vom Anbieter hoch. Mir ist bewusst, dass dadurch der Anbieter Daten
hat, um zu sehen, wann etwa die Kaffeemaschine angeschaltet wird, oder wann gekocht wird.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Tages-Ansicht im Web&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/pv-anlage-online.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Die hochgeladenen Daten können über die Web-Oberfläche von Kostal oder über die
App eingesehen werden. Leider ist hier schon ein Problem da, denn manchmal verschluckt
der Wechselrichter scheinbar die Daten und lädt diese nicht zuverlässig hoch.
Das führt zu Lücken in den Graphen des Tages und es lässt sich keine zuverlässigen
Auswertungen zu. Für den Monat Juli waren etwa an vier Tagen fast keine Daten
hochgeladen worden, was die hinterlegte Statistik für die einzelnen Tage/Monat/Jahre
verfälscht und unbrauchbar macht.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Tages-Ansicht in der App&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/pv-anlage-app.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Die App kann nicht nur die Daten von den Servern laden und mittelmäßig darstellen,
sondern auch Live-Daten anzeigen. Dazu muss sich das Handy aber im selben Netzwerk
wie der Wechselrichter befinden. Dargestellt wird dann der aktuelle Ertrag der
PV-Anlage, die aktuelle Einspeisung ins Netz, der aktuelle Verbrauch des Hauses
und Füllstand und Lade/Entlade-Kapazität von einer Batterie. Da ich keine Batterie
habe, ist die entsprechend immer bei 0.&lt;/p&gt;
&lt;p&gt;Die Qualität der App war auch eher mittelmäßig. Häufig hat die App die Zugangsdaten
vergessen und man musste sich diese immer wieder neu eintippen. Auch die grafische
Darstellung war eher schlecht, da sich einige Zahlen in den Graphen überlappen,
wenn das Smartphone im Hochformat verwendet wird. Prinzipiell praktisch ist
hingegen die Möglichkeit pro Stunde, Tag, Woche, Monat und Jahr die Verbrauchs-
und Ertragsdaten darstellen zu lassen. Aufgrund der sporadischen Aussetzer war
dies mir allerdings auch nicht zufriedenstellend genug.&lt;/p&gt;
&lt;p&gt;Neben dem Online-Portal und der App hat der Wechselrichter noch einen Webserver
laufen, über den man einige Daten abrufen kann. Dies ist nur im lokalen Netz
erreichbar und nutzt dieselbe Schnittstelle, wie die App.&lt;/p&gt;
&lt;h2 id=&#34;eigene-datenhaltung&#34;&gt;Eigene Datenhaltung&lt;/h2&gt;
&lt;p&gt;Aufgrund der eher mäßigen Qualität der Software musste also eine eigene
Datenhaltung her. Nicht, weil ich unbedingt genaue Daten brauche, sondern weil es geht
und weil ich es kann.&lt;/p&gt;
&lt;p&gt;Die zuvor angesprochene Web-Oberfläche des Wechselrichters sind lediglich ein paar einfache
HTML-Seiten mit JavaScript. Um an die Daten des Wechselrichters zu kommen, musste
also ein wenig „Reverse-Engineering“ durchgeführt werden. Das hab ich bewusst
in Anführungsstrichen geschrieben, weil das, was ich getan hab, viel zu einfach
ist, als es Reverse-Engineering zu nennen.&lt;/p&gt;
&lt;p&gt;Der JavaScript Code sendet alle paar Sekunden HTTP-Anfragen an den Wechselrichter,
in dem es lange IDs hinschickt und Antworten als Key-Value Paare zurückerhält. Aus
den IDs und somit auch Keys der Antworten, lässt sich nicht aus Anhieb erkennen,
was für ein Wert das ist. Mit ein wenig logisches Denken, kann man das allerdings
sehr schnell mit den Werten aus der Web-Oberfläche verknüpfen. Dazu war auch
ein Blick in den Netzwerk-Tab der Web-Konsole hilfreich. Kompliziert war das nicht,
eher ein wenig nervige Handarbeit.&lt;/p&gt;
&lt;p&gt;Um nun die aktuellen Daten auszulesen, habe ich ein Python-Skript geschrieben,
welches anhand der IDs die Daten über die REST-Schnittstelle abruft und in eine
PostgreSQL-Datenbank schreibt. Das Skript ist im GitHub-Repository &lt;a href=&#34;https://github.com/svijee/kostal-dataexporter&#34;&gt;svijee/kostal-dataexporter&lt;/a&gt;
zu finden. Komplex ist das ganze nicht. Das Skript läuft bei mir innerhalb
eines Docker Containers und schreibt es in die Datenbank. Das Skript ist nicht
wirklich schön – aber es funktioniert!&lt;/p&gt;
&lt;p&gt;Die Daten möchte ich natürlich auch noch visualisieren. Dazu habe ich (natürlich)
Grafana im Einsatz, wofür ich ein Dashboard gebaut habe. Zum jetzigen Zeitpunkt
hat es allerdings nicht die gleichen Features wie die App bzw. das Web-Portal von
Kostal. Ich kann nämlich bislang nur die Daten von einem Tag darstellen und
es findet noch keine praktisch-nutzbare Aggregierung der Daten über mehrere Tage,
Wochen, Monate oder Jahre statt. Ich kann daher etwa nicht anschauen, wie viel
Strom pro Tag oder Woche erzeugt wurde.&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;PV-Anlage über Grafana&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/pv-anlage-grafana.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;In dem Screenshot lässt sich einiges Interessantes herauslesen. Oben links ist
der Graph für den Gesamtertrag der Anlage und unten links der Graph für die Einspeisung in
das öffentliche Netz. Wie man daraus erkennen kann, läuft der untere Graph gegen
eine Grenze bei fast 5 kW. Dies hängt damit zusammen, dass der Netzbetreiber (in
meinem Fall Westnetz) für die EEG-Vergütung nur bis zu 70% der Peak-Leistung der
Anlage annehmen müssen. Das entspricht bei meiner Anlage eine maximale Leistung
bei der Einspeisung von 4690 W. Der Eigenverbrauch des Hauses wird da nicht
mit eingerechnet, sodass alles über 70% Leistung reduziert wird, d.h. es eine
künstliche Leistungsreduzierung stattfindet, sofern der Strom nicht selbst verwendet
wird. Alles über 70% der Peak-Leistung ist somit kostenfreier Strom, da dieser
sonst „verpufft“. Aus ökologischer Sicht ist diese 70% Regelung natürlich Unfug,
da sauberer Strom künstlich reduziert wird, nur, damit der Netzbetreiber nicht alles
an produzierten Strom ankaufen muss. Als PV-Anlagen Betreiber heißt das dann natürlich:
Möglichst viel Strom tagsüber verbrauchen.&lt;/p&gt;
&lt;p&gt;Zurück zum technischen! Die übrigen Daten, die auf dem Dashboard zu sehen sind,
sind alles Daten, die direkt von der REST-Schnittstelle vom Wechselrichter
kommen. Viel Magie passiert da also nicht.&lt;/p&gt;
&lt;p&gt;Rechts sieht man noch zwei Graphen: den Stromverbrauch im Haus, sowie darunter
pro Phase. Letzteres interessiert mich in der Praxis nicht wirklich. Aus dem
Stromverbrauch im Haus lassen sich diverse Informationen auslesen. Man erkennt
gut, wann der Herd an war und man erkennt häufig auch sehr gut, wenn die Personen
im Haushalt aufstehen, da der angeschaltete Wasserkocher ebenfalls erkennbar ist.
An Tagen wo keiner zu Hause ist, erkennt man auch sehr gut den laufenden Kühlschrank,
der in regelmäßigen Abständen für eine gewisse Zeit kühlt und dann in den Standby wechselt.
Für mich zeigte das deutlich, dass man aus diesen Metadaten einiges erkennen kann,
was auch ein wesentlicher Kritikpunkt von smarten Stromzählern sind.&lt;/p&gt;
&lt;p&gt;Ein weiterer Punkt, der aus dem Graphen zu erkennen ist, dass Nachts keine Erfassung
des Stromverbrauchs erfolgt. Dies hängt damit zusammen, dass der Sensor, der den
Stromverbrauch des Hauses misst, nur dann läuft, wenn Strom aus der Photovoltaik-Anlage
bekommt. Der Hauptzweck des Sensors ist die Berechnung, wieviel Strom in das Netz
eingespeist werden kann, wenn gleichzeitig Strom im Haus verbraucht wird. Dies hängt
erneut mit der 70% Regelung zusammen. Kostal hält es jedenfalls nicht für notwendig,
dass man den Sensor so nutzen kann, dass man 24h den Stromverbrauch im Haus messen kann. Um
dies zu ermöglichen, bräuchte ich eine Batterie, die wiederum aktuell noch zu teuer
ist.&lt;/p&gt;
&lt;h2 id=&#34;auswertung&#34;&gt;Auswertung&lt;/h2&gt;
&lt;p&gt;Spannend war für mich die Auswertung der Daten nach einem Jahr. Die Firma, die mir
die Photovoltaik-Anlage montiert hat, hat über ein Programm ausgerechnet, wie
hoch die möglichen Erträge für meine Anlage ist. Das war keine einfache Excel-Tabelle
(wie sie teilweise andere Firmen genutzt haben), sondern ein Programm, was diverse
Faktoren einkalkuliert hat. Darunter die Sonnenstunden der letzten Jahre auf
den Koordinaten, den Winkel der Anlage auf dem Dach und der Winkel zur Sonne
und mögliche Schattierungen von Bäumen in der Nähe.&lt;/p&gt;
&lt;p&gt;Relevant für die Amortisation ist sowohl der Strombedarf für einen selbst, als auch
ein möglichst hoher Eigenverbrauch, da dann weniger Strom vom Stromanbieter bezogen
werden muss, da dies deutlich teurer ist.&lt;/p&gt;
&lt;p&gt;Unser Jahresverbrauch im Vorjahr lag bei uns bei etwa 3800 kWh bei einem 2,5 Personen
Haushalt. Dies diente dann als Berechnungsgrundlage für den Amortisierungsplan.
Folgende Leistungsdaten berechnete das Programm von der Firma:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;
&lt;p&gt;Ertrag der PV-Anlage: 6410 kWh&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;davon 1680 kWh Eigenverbrauch&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;davon 4730 kWh Netzeinspeisung&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;Gesamtverbrauch: 3800 kWh&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;davon 1680 kWh durch PV&lt;/p&gt;
&lt;/li&gt;
&lt;li&gt;
&lt;p&gt;davon 2128 kWh durch Netz&lt;/p&gt;
&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Die Realität ein Jahr später sieht spannend aus:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Ertrag der PV-Anlage: 7405 kWh (+995 kWh , +13,4%)&lt;/li&gt;
&lt;li&gt;1600 kWh Eigenverbrauch (-80 kWh, -5%)&lt;/li&gt;
&lt;li&gt;5805 kWh Einspeisung (+1075 kWh, +18,5%)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Der Gesamtverbrauch lag fast genau bei der Schätzung:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Gesamtverbrauch: 3793 kWh (-8 kWh, -0,01%)&lt;/li&gt;
&lt;li&gt;1600 kWh durch PV (-80 kWh, -5%)&lt;/li&gt;
&lt;li&gt;2193 kWh durch Netz (+65 kWh, +3%)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Wie man sieht, sind die geschätzten Werte nahezu insignifikant höher oder niedriger
als geschätzt, mit einer krassen Ausnahme: der Gesamtertrag der PV-Anlage und somit
auch die Einspeisung in das öffentliche Netz. Da schien die Sonne wohl deutlich mehr
als die Jahre zuvor.&lt;/p&gt;
&lt;p&gt;Und hier noch ein paar Funfacts:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Der Monat mit dem höchsten Ertrag war der Juni mit über 1000 kWh&lt;/li&gt;
&lt;li&gt;Photovoltaik-Anlagen arbeiten besser, wenn es kühler ist. Der Juli war deutlich zu heiß, das sieht man deutlich an den Ertragsgraphen&lt;/li&gt;
&lt;li&gt;Der Tag mit dem höchsten Ertrag war der 15. Mai mit 46,4 kWh&lt;/li&gt;
&lt;li&gt;Die Screenshots oben sind von dem Tag&lt;/li&gt;
&lt;li&gt;Der Tag mit dem geringsten Ertrag war der 16. Dezember mit 0,7 kWh&lt;/li&gt;
&lt;li&gt;Das war einer der wenigen Tage mit 100% Eigenverbrauchsquote&lt;/li&gt;
&lt;/ul&gt;
&lt;h2 id=&#34;fazit&#34;&gt;Fazit&lt;/h2&gt;
&lt;p&gt;Rein finanziell lohnt sich so eine Photovoltaik-Anlage für mich. Aus technischer
Sicht machte das schon viel Spaß sich damit näher auseinander zu setzen, und damit
mein ich sowohl generell das Thema Photovoltaik, als auch die Erfassung, Auswertung
und Visualisierung der Daten. Persönlich fehlt mir ja noch eine Batterie, um den
Eigenverbrauch zu steigern. Dazu lag mir zwar auch ein Angebot vor, doch 33% Aufpreis
bei einer längeren Amortisationsdauer von +50% war nicht wirklich sinnvoll. Da
warte ich lieber auf hoffentlich günstigere Angebote in Zukunft für Batterien, da diese sich
ja mit überschaubaren Aufwand nachrüsten lassen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>GPN19: Über dämliche Aktionen in Git-Repositorys als Vortrag</title>
      <link>https://svij.org/blog/2019/06/01/gpn19-%C3%BCber-d%C3%A4mliche-aktionen-in-git-repositorys-als-vortrag/</link>
      <pubDate>Sat, 01 Jun 2019 08:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/06/01/gpn19-%C3%BCber-d%C3%A4mliche-aktionen-in-git-repositorys-als-vortrag/</guid>
      <description>&lt;p&gt;Zwei von vier Tagen war ich auf der &lt;a href=&#34;https://entropia.de/GPN19&#34;&gt;19. Gulaschprogrammiernacht&lt;/a&gt; in Karlsruhe,
was vom &lt;a href=&#34;https://entropia.de/Hauptseite&#34;&gt;Entropia e.V.&lt;/a&gt; vom 30. Mai bis 2. Juni veranstaltet
wurde. Für mich war es der erste Besuch bei der Veranstaltung und die zweite
CCC-nahe Veranstaltung nach dem Besuch des 34c3.&lt;/p&gt;
&lt;p&gt;Die, die mich kennen, wissen ja, dass ich (sehr) häufig bei solchen Veranstaltungen
Vorträge halte. Mein Hauptthema die letzten Jahre war ja eigentlich fast ausschließlich
verschiedene Unterthemen zur Versionskontrolle mit Git. Von vielen Personen
höre ich mittlerweile auch nur noch „Du erzählst ja immer nur von dem einem Thema!“.
Was auch nicht falsch ist.&lt;/p&gt;
&lt;p&gt;Für dieses Mal habe ich mir einen Vortrag ausgedacht mit dem Titel „Dämliche Dinge mit Git Repositorys anstellen“.
Dabei ging es nicht nur um technische, sondern auch soziale Aspekte, die man
so falsch machen kann. Versucht habe ich, technische interne Funktionsweisen von
Git an Hand von Negativbeispielen zu erläutern und mit ein wenig Humor zu untermalen.
Das hat, denke ich, recht gut geklappt. Zielgruppe waren nicht absolute Einsteiger,
aber auch Experten konnten wohl aus den Inhalten nicht sehr viel abgewinnen.&lt;/p&gt;
&lt;p&gt;Die „Folien“ (Warum nennt man das eigentlich noch Folien?) finden sich auf
&lt;a href=&#34;https://speakerdeck.com/svij/gpn19-damliche-dinge-mit-git-repositorys-anstellen&#34;&gt;Speakerdeck&lt;/a&gt;
oder mit aktivierten JavaScript auch hier eingebunden:&lt;/p&gt;
&lt;script async class=&#34;speakerdeck-embed&#34; data-id=&#34;7bdc9f02d28c47d09b4478ff8a1cb81e&#34; data-ratio=&#34;1.77966101694915&#34; src=&#34;//speakerdeck.com/assets/embed.js&#34;&gt;&lt;/script&gt;
&lt;p&gt;Das &lt;a href=&#34;https://c3voc.de&#34;&gt;c3voc&lt;/a&gt; erledigt ja schon seit Jahren sehr sehr gute Arbeit
um Vorträge aufzuzeichnen, zu streamen und zügig zu veröffentlichen. Diese finden
sich bekanntlich unter &lt;a href=&#34;https://media.ccc.de&#34;&gt;media.ccc.de&lt;/a&gt;. Dort findet sich
auch mein &lt;a href=&#34;https://media.ccc.de/v/gpn19-4-dmliche-dinge-mit-git-repositorys-anstellen&#34;&gt;Vortrag&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Alternativ gibt es auch die Einbindung hier:&lt;/p&gt;
&lt;iframe width=&#34;1024&#34; height=&#34;576&#34; src=&#34;https://media.ccc.de/v/gpn19-4-dmliche-dinge-mit-git-repositorys-anstellen/oembed&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
&lt;p&gt;Das sehr viele Leute Git verwenden ist ja im Prinzip nichts Neues. Was mir nur
Vorträge wie diese immer wieder verdeutlichen ist, dass zwar viele Leute Git
nutzen, aber viele nützliche Funktionen nicht kennen oder Bedarf an
weiteren Informationen gesehen wird. Ansonsten wäre wohl der Vortragsraum nicht
vollständig gefüllt gewesen, wo (fast) die Hälfte der Zuhörer hinten stand&amp;hellip;&lt;/p&gt;
&lt;p&gt;Auf der diesjährigen &lt;a href=&#34;https://www.froscon.de/&#34;&gt;FrOSCon&lt;/a&gt; werde ich eine Neu-Auflage
dieses Talks halten. Vermutlich werde ich dazu noch ein paar Anpassungen durchführen,
es wird aber im wesentlichen ähnlich sein. Damit ich mich auch mal mit anderen
Themen beschäftige, habe ich auch einen Vortrag zu &lt;a href=&#34;https://prometheus.io/&#34;&gt;Monitoring mit Prometheus&lt;/a&gt;
eingereicht, der auch angenommen wurde.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Open und Closed Source Software beim Schreiben des Git-Buches (2. Auflage)</title>
      <link>https://svij.org/blog/2019/05/12/open-und-closed-source-software-beim-schreiben-des-git-buches-2.-auflage/</link>
      <pubDate>Sun, 12 May 2019 17:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/05/12/open-und-closed-source-software-beim-schreiben-des-git-buches-2.-auflage/</guid>
      <description>&lt;p&gt;2016 erschien die &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/&#34;&gt;erste Auflage meines Git-Buches&lt;/a&gt;,
bei dem ich auch darüber &lt;a href=&#34;https://svij.org/blog/2016/08/03/ein-buch-mit-open-und-closed-source-software-schreiben/&#34;&gt;schrieb&lt;/a&gt;,
welche Open und Closed Source Software ich verwendet habe, um das Buch zu schreiben.&lt;/p&gt;
&lt;p&gt;In diesem Artikel geht es um das gleiche Thema wie letztes Mal, mit dem Unterschied,
dass ich über die Arbeit an der &lt;a href=&#34;https://svij.org/blog/2019/05/10/zweite-auflage-meines-git-buches-erschienen/&#34;&gt;zweiten Auflage des Buches&lt;/a&gt;
welches jetzt erschien. Nähere Informationen zu dem Buch finden sich hinter dem Link.&lt;/p&gt;
&lt;p&gt;Allgemein geht es in diesem Artikel die Tools die ich selbst verwendet habe und
nicht die, die beim Verlag eingesetzt wurde. Wie auch im letzten Mal habe ich
versucht so viel Open-Source-Software wie möglich einzusetzen.&lt;/p&gt;
&lt;h2 id=&#34;das-schreiben&#34;&gt;Das Schreiben&lt;/h2&gt;
&lt;p&gt;Bei der ersten Auflage schrieb ich den ersten Entwurf zunächst in Vim und
überführte es dann nach LibreOffice Writer, wo die Dateien dann vom Verlag
weiterverarbeitet wurden.&lt;/p&gt;
&lt;p&gt;Für die zweite Auflage arbeitete ich direkt in LibreOffice weiter, wo ich die
Änderungen eingepflegt habe. Um ein Diff zwischen den Versionen anschauen zu
können, verwendete ich &lt;strong&gt;odt2txt&lt;/strong&gt;, was ich in meine Git-Konfiguration eingebunden
habe. Das funktioniert zwar nicht so gut wie bei reinen Text-Dateien, aber besser so,
als gar kein Diff zu haben.&lt;/p&gt;
&lt;p&gt;Beim Verlag bzw. beim Satz des Buches wurde FrameMaker verwendet. Berührungspunkte
hatte ich allerdings damit keine.&lt;/p&gt;
&lt;h2 id=&#34;die-grafiken&#34;&gt;Die Grafiken&lt;/h2&gt;
&lt;p&gt;Im Buch muss ich diverse Dinge visualisieren. Dazu gehören sowohl Darstellungen
der Git-Historie, als auch Veranschaulichungen bei Workflows beim Arbeiten mit
Remote-Repositorys.&lt;/p&gt;
&lt;p&gt;In der ersten Auflage griff ich nach einigen Experimenten mit Tools wie &lt;a href=&#34;http://www.graphviz.org&#34;&gt;Graphviz&lt;/a&gt;
auf &lt;a href=&#34;https://www.yworks.com/products/yed&#34;&gt;yEd Graph Editor&lt;/a&gt;. Hauptgrund für die
Auswahl von yEd war, dass ich ohne größeren Anstrengungen und mit wenig Aufwand
solche Grafiken erstellen konnte. Nachteil von yEd: es ist ein kein quelloffenes
Tool und die enthaltenen Abbildungen empfand ich zum Teil als altbacken.&lt;/p&gt;
&lt;p&gt;Als neues Tool setzte ich dieses Mal auf &lt;a href=&#34;https://www.draw.io/&#34;&gt;draw.io&lt;/a&gt;. Das
funktioniert sowohl im Browser bzw. Web, als auch als Electron Anwendung auf dem
Desktop. Ich griff dabei auf die Installation über das &lt;a href=&#34;https://flathub.org/apps/details/com.jgraph.drawio.desktop&#34;&gt;Flatpak-Paket&lt;/a&gt;
zurück. Das Tool steht zwar unter der Apache 2.0 Lizenz, die Entwicklung geschieht
allerdings größtenteils im Verborgenen. Das sieht man auch sehr stark, wenn
man sich die &lt;a href=&#34;https://github.com/jgraph/drawio/commits/master&#34;&gt;Git-Historie&lt;/a&gt; auf
dem master Branch anschaut: Bis auf wenige Ausnahmen enthält jeder einzelne Commit die
Änderungen einer kompletten Version. Eine nachvollziehbare Historie ist dies
hingegen nicht.&lt;/p&gt;
&lt;p&gt;Eine Migration der mit yEd erstellen Grafiken war allerdings nicht möglich, sodass
ich alle Grafiken neu erstellt habe.&lt;/p&gt;
&lt;h2 id=&#34;statistiken&#34;&gt;Statistiken&lt;/h2&gt;
&lt;p&gt;Bei der ersten Auflage konnte ich noch eine kleine Statistik erstellen
in dem ich die Anzahl und Uhrzeiten der Git-Commits ausgewertet habe. Dies ging
bei der zweiten Auflage nicht ganz so gut, weil viel weniger Commits notwendig
waren. Ich begann die Arbeit an der zweiten Auflage am Heiligabend 2018 und endete
am 26. April 2019. Insgesamt wurden es 53 Commits. Effektiv gearbeitet habe ich
in diesem Zeitraum natürlich nicht jeden Tag, da ich fast ausschließlich am
Wochenenden, Urlaubstagen und in Zügen der Deutschen Bahn daran gearbeitet habe.
Zum Vergleich: Für die Fertigstellung der ersten Auflage lagen zwischen dem ersten
und dem letzten Commit 308 Tage und 287 Commits, also knapp über 10 Monate.&lt;/p&gt;
&lt;h2 id=&#34;und-nun&#34;&gt;Und nun?&lt;/h2&gt;
&lt;p&gt;Mit Abschluss meines Masterabschlusses Anfang Dezember und Fertigstellung der
zweiten Auflagen des Buches sind meine Großprojekte der letzten Jahre erstmal
abgeschlossen. Mal schauen was ich mir jetzt ans Bein binde. ;)&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Chemnitzer Linux-Tage: Nachvollziehbare Git Historien (Vortrag)</title>
      <link>https://svij.org/blog/2019/03/17/chemnitzer-linux-tage-nachvollziehbare-git-historien-vortrag/</link>
      <pubDate>Sun, 17 Mar 2019 20:20:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2019/03/17/chemnitzer-linux-tage-nachvollziehbare-git-historien-vortrag/</guid>
      <description>&lt;p&gt;Am Wochenende fanden die 21. &lt;a href=&#34;https://chemnitzer.linux-tage.de/2019&#34;&gt;Chemnitzer Linux-Tage&lt;/a&gt;
an der TU Chemnitz statt. Für mich war es nun schon der dritte Besuch nach
2015 und &lt;a href=&#34;https://www.credativ.de/blog/r%C3%BCckschau-auf-die-20-chemnitzer-linux-tage&#34;&gt;2018&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Zu Vorträgen aus dem &lt;a href=&#34;https://chemnitzer.linux-tage.de/2019/de/programm&#34;&gt;Vortragsprogramm&lt;/a&gt;
kann ich nicht sehr viel sagen. Wie es sich bei mir mittlerweile
Standard ist, bin ich mehr in Gesprächen mit den zahlreichen Freunden „verwickelt“
gewesen und weniger in Vorträgen gewesen. Am Samstag habe ich es immerhin
geschafft den einzigen Vortrag für mich an diesem Tag zu besuchen: &lt;a href=&#34;https://chemnitzer.linux-tage.de/2019/de/programm/beitrag/259&#34;&gt;„Python asyncio in der Praxis“&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Am Sonntag habe ich es ebenfalls nur zu einem
Talk geschafft. Allerdings war ich da der Speaker und musste (viel) reden. Wie
auch bei der letzten &lt;a href=&#34;https://openrheinruhr.de&#34;&gt;OpenRheinRuhr&lt;/a&gt; erzählte ich
über &lt;a href=&#34;https://chemnitzer.linux-tage.de/2019/de/programm/beitrag/196&#34;&gt;„How To Commit: Nachvollziehbare Git-Historien“&lt;/a&gt;.
In diesem Vortrag erzählte ich über die Art und Weise wie Commits auszusehen
haben sollten, damit diese auch im Nachhinein nachvollziehbar sind. Der Talk war auch
als Diskussion ausgerichtet, weshalb einige Informationen und Wortmeldungen entsprechend nicht in
den „Folien“ enthalten sind. Eine Aufzeichnung des Talks gab es hingegen und wird
hoffentlich zeitnah auf der Webseite vom CLT veröffentlicht.&lt;/p&gt;
&lt;p&gt;Die Folien finden sich auf meinem &lt;a href=&#34;https://speakerdeck.com/svij&#34;&gt;Speakerdeck&lt;/a&gt;
Account oder eingebettet (via JavaScript) auch hier:&lt;/p&gt;
&lt;script async class=&#34;speakerdeck-embed&#34; data-id=&#34;962f7bede84142c0bff7f000e2e4fc26&#34; data-ratio=&#34;1.77966101694915&#34; src=&#34;//speakerdeck.com/assets/embed.js&#34;&gt;&lt;/script&gt;
&lt;p&gt;Das Thema des Talks wird für mich im Umgang mit Git immer wichtiger, sodass es
in der kommenden zweiten Auflage &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/&#34;&gt;meines Git Buches&lt;/a&gt;
ein eigenständiges Kapitel gewidmet bekommen wird.&lt;/p&gt;
&lt;p&gt;Unabhängig von meinem Talk lohnt sich ein Besuch der Chemnitzer Linux-Tage
auch weiterhin. Eine schöne nette Community die sich da trifft. Für mich auch
die Open-Source-Konferenz, die ich am besten mag. Und das liegt nicht nur an der
guten Organisation… :)&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git Merge-Konflikte lösen mit fac</title>
      <link>https://svij.org/blog/2018/02/09/git-merge-konflikte-l%C3%B6sen-mit-fac/</link>
      <pubDate>Fri, 09 Feb 2018 08:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2018/02/09/git-merge-konflikte-l%C3%B6sen-mit-fac/</guid>
      <description>&lt;p&gt;Wer häufiger mit Git arbeitet und dort auf Merge-Konflikte stößt, hat bei größeren
Konflikten keinen sonderlich großen Spaß diese aufzulösen. Häufig bietet es
sich dabei an, ein Mergetool zu verwenden, der einem die Arbeit erleichtern soll.
Einige Mergetools existieren für die Kommandozeile, andere auch als grafische
Tools.&lt;/p&gt;
&lt;p&gt;Kürzlich bin ich auf das kleine Tool „&lt;a href=&#34;https://github.com/mkchoi212/fac&#34;&gt;fac&lt;/a&gt;“ gestoßen, was
kurz für „Fix All Commits“ steht. „fac“ ist ein in Go geschriebenes CUI, also
ein Commandline User Interface, um Merge-Konflikte aufzulösen.&lt;/p&gt;
&lt;p&gt;Das Schöne daran ist die einfache Nutzung und die übersichtliche Darstellung
im Terminal, der zunächst erstmal nur die benötigten und relevanten Zeilen anzeigt.
Zusätzliche Zeilen lassen sich allerdings mit wenigen Tastendrücken anzeigen.&lt;/p&gt;
&lt;p&gt;Aussehen tut dies etwa so:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Git Merge fac&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/git-merge-fac.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;„fac“ ist in Go geschrieben und kann über &lt;code&gt;go&lt;/code&gt; auch heruntergeladen werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ go get github.com/mkchoi212/fac
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Die Binärdatei liegt anschließend unter &lt;code&gt;~/go/bin/fac&lt;/code&gt;. Den Pfad sollte man dann
entweder zu seiner &lt;code&gt;$PATH&lt;/code&gt; Variable hinzufügen oder direkt aufrufen. Leider
gibt es noch keine Unterstützung als Git Mergetool. Dazu existiert aber ein
&lt;a href=&#34;https://github.com/mkchoi212/fac/issues/4&#34;&gt;Issue&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Natürlich gibt es auch andere Mergetools, die man verwenden kann. Mir gefällt in
diesem Fall die einfache Benutzung und die geringe Einstiegshürde, die das Tool
mit sich bringt. Verbesserungspotenzial ist da natürlich auch da, da eine schönere
Diff-Ansicht des Konfliktes begrüßenswert wäre.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Machine Learning with Python</title>
      <link>https://svij.org/blog/2018/02/07/rezension-machine-learning-with-python/</link>
      <pubDate>Wed, 07 Feb 2018 20:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2018/02/07/rezension-machine-learning-with-python/</guid>
      <description>&lt;p&gt;Nach längerer Zeit folgt an dieser Stelle mal wieder eine Buchrezension. In
diesem Artikel wird das Buch „Machine Learning mit Python“ mit dem Untertitel
„Das Praxis-Handbuch für Data Science, Predictive Analytics und Deep Learning“
vom Autor Sebastian Raschka besprochen. Erschienen ist das Buch beim mitp Verlag.
Zu dem handelt es sich bei diesem Buch um eine Übersetzung aus dem Englischen.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Hinweis&lt;/strong&gt;: Der mitp Verlag stellte mir für die Rezension ein Rezensionsexemplar
frei zur Verfügung. Das Buch erschien in der deutschen Übersetzung bereits
am 30. November 2016, am 22. Dezember 2017 folgt dann schon die &lt;a href=&#34;http://www.mitp.de/733&#34;&gt;zweite Auflage&lt;/a&gt;,
in dem der Fokus um TensorFlow erweitert wurde. Diese Rezension richtet sich
explizit auf die &lt;strong&gt;erste&lt;/strong&gt; Auflage des Buches. Genannte Kritik-Punkte können
durchaus korrigiert bzw. verbessert worden sein.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Das Buch unterteilt sich in 13 Kapiteln, die insgesamt 424 Seiten umfassen. Das
Buch beginnt zunächst mit einem in das maschinelle Lernen, dabei wird auf die
drei verschiedenen Arten eingegangen und beispielhaft erläutert, sowie in die
Notation und Terminologie in dem Fachbereich eingegangen. Im zweiten Kapitel
folgt direkt schon die erste Übung, in der ein Lernalgorithmus programmiert
und erläutert wird, der für die Klassifizierung trainiert wird. Weiter geht
es im dritten Kapitel über die Verwendung von scikit-learn, welches die
Bibliothek ist, die in diesem Buch verwendet wird, um Machine Learning
Algorithmen zu implementieren. Die ersten Kapitel setzten noch auf vorgefertigte
Datensätze, die man nicht selbst ermitteln musste. In Kapitel 4 und 5 geht es
daher um die Datenvorverarbeitung und die Datenkomprimierung, damit man das in
den selbst geschriebenen Klassifizierern verwenden kann.&lt;/p&gt;
&lt;p&gt;Je weiter man in dem Buch liest, desto tiefer gehen auch die Themen, so werden
in den darauf folgenden Kapiteln Hyperparameter-Abstimmung und die Kombination
verschiedener Modelle thematisiert. Das achte Kapitel führt wiederum in das
Thema des Natural Language Processings ein, wo erklärt wird, wie man
Stimmungsanalysen ableiten kann.&lt;/p&gt;
&lt;p&gt;Das Buch führt aber auch in die Praxis ein, denn die bisherigen Kapitel
erläuterten nur an Hand von Skripten, die bei jedem Lauf von vorne aus den
Daten gelernt haben. Im neunten Kapitel wird exemplarisch gezeigt, wie man eine
Web-Anwendung implementieren kann, welches die zuvor implementierten
Algorithmen nutzt und während der Nutzung auch weiter lernt und anwendet. Die
übrigen Kapitel umfassen weiterhin eine Regressionsanalyse, Clusteranalyse, die
Verwendung neuronale Netze zur Bildererkennung, sowie neuronale Netze mit der
Bibliothek Theano.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Das Buch ist sehr umfangreich und bietet sehr viele Informationen zu dem doch
großen Bereich des Machine Learnings. Der größte Kritik-Punkt meinerseits ist,
dass es nicht wirklich einsteigerfreundlich ist. Für viele Themen sind zwar
Beschreibungen und Erklärungen da, allerdings sind diese zumeist relativ knapp
und nicht immer ganz nachvollziehbar. Das Buch ist zwar schon relativ
umfangreich, doch könnte dies einen Tick umfangreicher sein, um vor allem
Einsteiger abzuholen. In dem Fall müssen für einige Themenbereiche nämlich noch
zusätzliche Quellen bezogen werden, um auch die Gedankengänge der Umsetzung
besser nachvollziehen zu können. Auch Erfahrung im Umgang mit Python ist sehr
vorteilhaft. Wer keine Erfahrung in beiden Gebieten mitbringt, wird mit dem
Buch eher nicht glücklich.&lt;/p&gt;
&lt;p&gt;Hier sollte man allerdings noch beachten, dass die zweite Auflage erschienen
ist, die nicht nur scikit-learn verwendet, sondern auch tiefer in die populäre
Bibliothek TensorFlow einführt. Das Buch ist in der zweiten Auflage somit auch
noch umfassender geworden.&lt;/p&gt;
&lt;p&gt;Unabhängig davon gilt es hervorzuheben, dass das Buch für die Zielgruppe von
Personen mit Erfahrung mit Python und den Grundzügen von Machine Learning sehr
viele Informationen und praxisrelevante Informationen vermittelt. Dass es eine
Übersetzung aus dem Englischen ist, merkt man dem Buch nicht an. Man sieht auch
sehr deutlich, dass der Autor viele Kenntnisse und Erfahrung in dem Bereich hat,
da er an vielen Stellen auf mögliche Probleme eingeht und passende Lösungen
parat hat.&lt;/p&gt;
&lt;h3 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; &lt;a href=&#34;https://www.amazon.de/dp/B01MXOGW9T&#34;&gt;Machine Learning mit Python&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Sebastian Raschka&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt; mitp&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt; 424 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt; 3958454224&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 49,99€&lt;/p&gt;
&lt;p&gt;&lt;em&gt;&lt;strong&gt;&lt;a href=&#34;http://www.mitp.de/733&#34;&gt;Hier gehts zur zweiten Auflage!&lt;/a&gt;&lt;/strong&gt;&lt;/em&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Schönere Git Diffs im Terminal mit diff-so-fancy</title>
      <link>https://svij.org/blog/2018/01/12/schonere-git-diffs-im-terminal-mit-diff-so-fancy/</link>
      <pubDate>Fri, 12 Jan 2018 19:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2018/01/12/schonere-git-diffs-im-terminal-mit-diff-so-fancy/</guid>
      <description>&lt;p&gt;Es sind manchmal die kleinen Dinge, die einem im Terminal noch glücklicher machen,
für Probleme, die man vorher gar nicht hatte. Ein Beispiel ist etwa das Anzeigen von
Unterschieden zwischen zwei Versionen mit einer Datei mit &lt;code&gt;diff&lt;/code&gt; bzw. in diesem
Fall ein einfaches &lt;code&gt;git diff&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Mit &lt;code&gt;diff-so-fancy&lt;/code&gt; lässt sich das Git Diff spürbar aufhübschen, sodass es besser
für den Menschen lesbar ist. Wie so häufig sagen Bilder mehr als viele Worte,
weshalb hier ein Screenshot folgt, wo das Standard Diff verwendet wird:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Diff not so fancy&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/diff-not-so-fancy.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Und hier eins mit &lt;code&gt;diff-so-fancy&lt;/code&gt;:&lt;/p&gt;
&lt;p&gt;&lt;img alt=&#34;Diff so fancy&#34; loading=&#34;lazy&#34; src=&#34;https://svij.org/graphics/diff-so-fancy.webp&#34;&gt;&lt;/p&gt;
&lt;p&gt;Es sind zwar nur viele Kleinigkeiten die dadurch schöner und besser ersichtlich sind,
doch das reicht schon, um einen besseren Überblick über seine Änderungen zu
bekommen. Ich selbst bearbeite Dateien fast nur auf der Kommandozeile und schaue
auch die Diffs dort an – seien es die gerade bearbeiteten Dateien oder auch das
Diff aus der Git Historie.&lt;/p&gt;
&lt;p&gt;Das Git-Repository des Projektes findet sich auf &lt;a href=&#34;https://github.com/so-fancy/diff-so-fancy&#34;&gt;GitHub/so-fancy/diff-so-fance&lt;/a&gt;.
Die Installation kann entweder über NPM, Nix oder brew erfolgen. Schönerweise
gibt es für ArchLinux ein Paket, weshalb dort die Installation besonders einfach ist.
Aber auch sonst ist es lediglich ein einfaches Script, was auf dem
Dateisystem ohne Paketverwaltung problemlos irgendwo abgelegt werden kann.&lt;/p&gt;
&lt;p&gt;Ich nutze nahezu die Standard-Einstellungen, dessen Einrichtung in der
&lt;a href=&#34;https://github.com/so-fancy/diff-so-fancy#usage&#34;&gt;README#Usage&lt;/a&gt; zu finden sind.
Einzig &lt;code&gt;markEmptyLines&lt;/code&gt; habe ich explizit abgeschaltet. Die Einstellungen landen
lediglich in der &lt;code&gt;~/.gitconfig&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Danke an &lt;a href=&#34;https://c3vo.de/&#34;&gt;chris34&lt;/a&gt; für den Tipp.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Aufzeichnung und Folien des Git-Talks &amp; -Workshops auf der FrOSCon 2017</title>
      <link>https://svij.org/blog/2017/08/22/aufzeichnung-und-folien-des-git-talks-workshops-auf-der-froscon-2017/</link>
      <pubDate>Tue, 22 Aug 2017 19:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/08/22/aufzeichnung-und-folien-des-git-talks-workshops-auf-der-froscon-2017/</guid>
      <description>&lt;p&gt;Letztes Wochenende fand die 12. &lt;a href=&#34;https://www.froscon.de&#34;&gt;FrOSCon&lt;/a&gt; in St. Augustin
statt. Für mich war es die dritte FrOSCon in Folge. Ich selbst habe diesmal
zwar nicht den Ubuntu Stand betreut, stattdessen habe ich einen
„Git für Einsteiger Workshop“ durchgeführt, sowie den Vortrag „Nicht alltägliche
Git-Funktionen“ gehalten.&lt;/p&gt;
&lt;h3 id=&#34;nicht-alltägliche-git-funktionen&#34;&gt;Nicht alltägliche Git-Funktionen&lt;/h3&gt;
&lt;p&gt;Der Talk war schönerweise gut besucht und wurde auch, wie zahlreiche anderen
Talks, aufgezeichnet. Die „Folien“ des Talks finden sich auf meinem
&lt;a href=&#34;https://speakerdeck.com/svij/nicht-alltagliche-git-funktionen&#34;&gt;Speakerdeck-Account&lt;/a&gt;.&lt;/p&gt;
&lt;script async class=&#34;speakerdeck-embed&#34; data-id=&#34;87ea46c8bc1047739fa47f42212ddf33&#34; data-ratio=&#34;1.78086956521739&#34; src=&#34;//speakerdeck.com/assets/embed.js&#34;&gt;&lt;/script&gt;
&lt;p&gt;Alle Aufzeichnungen der FrOSCon finden sich auf &lt;a href=&#34;https://media.ccc.de/c/froscon2017&#34;&gt;media.ccc.de&lt;/a&gt;.
Meinen Vortrag findet man &lt;a href=&#34;https://media.ccc.de/v/froscon2017-1919-nicht_alltagliche_git-funktionen&#34;&gt;hier&lt;/a&gt;.&lt;/p&gt;
&lt;iframe width=&#34;1024&#34; height=&#34;576&#34; src=&#34;https://media.ccc.de/v/froscon2017-1919-nicht_alltagliche_git-funktionen/oembed&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
&lt;p&gt;Thema des Talks ist die Übersicht von Git-Funktionen, die man explizit nicht jeden
Tag braucht, aber immer mal wieder gebrauchen kann. Einige sind dabei alltäglicher
als die anderen Befehle. Details lassen sich dazu in dem Talk ansehen, wie zuvor
verlinkt.&lt;/p&gt;
&lt;h3 id=&#34;git-workshop-für-einsteiger&#34;&gt;Git-Workshop für Einsteiger&lt;/h3&gt;
&lt;p&gt;Während der Talk sich an fortgeschrittene Git-Nutzer richtete, war der Git-Workshop
für „blutige“ Anfänger. Auch hier waren erfreulicherweise genau die passenden
Leute da, die entweder noch nie ein Versionskontrollsystem verwendet haben, oder
die von Subversion umsteigen bzw. umsteigen wollen.&lt;/p&gt;
&lt;p&gt;Die „Folien“ sind hier ohne Erläuterungen, da ich diese mündlich erfolgten. Die
Folien finden sich ebenfalls &lt;a href=&#34;https://speakerdeck.com/svij/git-workshop-fur-einsteiger-1&#34;&gt;auf meinem Speakerdeck-Account&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Alternativ lohnt sich auch hier wieder mein &lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/#git-fur-einsteiger-teil-1&#34;&gt;Git Tutorial&lt;/a&gt;
auf meinem Blog bzw. auch mein &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/#mein-git-buch-beim-mitp-verlag-ist-da&#34;&gt;Buch&lt;/a&gt;.
Das Buch basiert nämlich auf meine Git Tutorial Reihe und der Workshop basiert
ebenfalls darauf.&lt;/p&gt;
&lt;script async class=&#34;speakerdeck-embed&#34; data-id=&#34;123c82a7d6e5452796ebd6ac60bca3f5&#34; data-ratio=&#34;1.78086956521739&#34; src=&#34;//speakerdeck.com/assets/embed.js&#34;&gt;&lt;/script&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Unabhängig von meinem Vortrag und Workshop fand ich die FrOSCon wieder einmal
sehr schön. Auch in diesem Jahr merkt man, wie sich die Organisation der Veranstaltung
sich jedes Jahr Schritt für Schritt verbessert, auch wenn sie schon zum 12. Mal
hintereinander stattfindet. In diesem Sinne: Vielen Dank an das Organisationsteam
der FrOSCon für die tolle Konferenz! Nächstes Jahr bin ich dann wohl wieder dabei. :)&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git-Talk und Git-Workshop auf der FrOSCon 2017</title>
      <link>https://svij.org/blog/2017/07/20/git-talk-und-git-workshop-auf-der-froscon-2017/</link>
      <pubDate>Thu, 20 Jul 2017 15:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/07/20/git-talk-und-git-workshop-auf-der-froscon-2017/</guid>
      <description>&lt;p&gt;Am 19. und 20. August findet in St. Augustin bei Bonn die &lt;a href=&#34;https://www.froscon.de/&#34;&gt;FrOSCon&lt;/a&gt;
statt. Für mich ist es mittlerweile eine der Open Source Veranstaltung neben
der OpenRheinRuhr und der Ubucon, die ich möglichst nicht verpassen will. Dieses
Jahr bin ich so da zum (erst) dritten Mal in Folge.&lt;/p&gt;
&lt;p&gt;Das Programm der diesjährigen FrOSCon &lt;a href=&#34;https://programm.froscon.de/2017/&#34;&gt;veröffentlicht&lt;/a&gt;.
Ich selbst bin dieses Mal mit einem Vortrag und einem Workshop vertreten.&lt;/p&gt;
&lt;h3 id=&#34;nicht-alltägliche-git-funktionen&#34;&gt;Nicht alltägliche Git-Funktionen&lt;/h3&gt;
&lt;p&gt;Im letzten Slot am Samstag um 17:45 findet mein Talk mit dem Titel „Nicht alltägliche Git-Funktionen
– Committen, Pushen, Mergen kann jeder – aber was gibt es darüber hinaus?“ statt.&lt;/p&gt;
&lt;p&gt;Wie der (Unter)Titel schon verrät, geht es hier eben nicht um die alltäglichen
Funktionen von Git, sondern die Funktionen, die man eher nicht so oft nutzt
und eben auch nicht jeden Tag braucht. Darunter fallen Funktionen wie die
Fehlersuche mit Git, das Neuschreiben der kompletten Historie, Wiederherstellen von
kaputten und „verlorenen“ Commits und noch einige weitere Funktionen.&lt;/p&gt;
&lt;p&gt;Der Talk richtet sich an diejenigen, die Git schon kennen und neue nützliche
Kenntnisse in der Nutzung gewinnen wollen. Der Link zum Programmpunkt findet
sich &lt;a href=&#34;https://programm.froscon.de/2017/events/1919.html&#34;&gt;an dieser Stelle&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;git-workshop-für-einsteiger&#34;&gt;Git-Workshop für Einsteiger&lt;/h3&gt;
&lt;p&gt;Für die Personen, die noch keine Erfahrung und Ahnung von Git haben, biete ich auch
noch einen Einsteiger-Workshop an. Dieser findet am Sonntag von 14 bis 18 Uhr
statt. In den vier Stunden wird es einen grundlegenden Einstieg in die Versionsverwaltung
mit Git. Konkret fällt darunter: Was ist Git und worin unterscheidet es sich von
anderen Versionsverwaltungssystemen? Wie erstelle ich ein Repository und füge
Änderungen hinzu? Wie erstelle ich Branches und führe sie wieder zusammen?&lt;/p&gt;
&lt;p&gt;Vier Stunden sind wahrlich nicht viel für einen Workshop. Je nach Zeit wird die
Arbeit mit Remote-Repositorys auf das nötigste beschränkt. Der Workshop empfiehlt
sich daher wirklich nur für die Leute, die wirklich noch nicht die wesentlichen
Git Funktionen kennen. Der Link zum offiziellen Programmpunkt findet sich
&lt;a href=&#34;https://programm.froscon.de/2017/events/1918.html&#34;&gt;an dieser Stelle&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Der Workshop basiert auf mein &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da&#34;&gt;Git-Buch&lt;/a&gt;.
Eben dieses Buch wird auch – wenn nichts dazwischen kommt – nach dem Workshop
und nach dem Talk verlost.&lt;/p&gt;
&lt;p&gt;Unabhängig von meinen Talk und Workshop lohnt sich natürlich auch ein Blick
auf die anderen Vorträge und Workshops &lt;a href=&#34;https://programm.froscon.de/2017/&#34;&gt;im Programm der FrOSCon&lt;/a&gt;!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>CRLF in LF automatisch umwandeln in Git-Repositorys</title>
      <link>https://svij.org/blog/2017/07/07/crlf-in-lf-automatisch-umwandeln-in-git-repositorys/</link>
      <pubDate>Fri, 07 Jul 2017 21:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/07/07/crlf-in-lf-automatisch-umwandeln-in-git-repositorys/</guid>
      <description>&lt;p&gt;Es sind manchmal viele Kleinigkeiten in einem Projekt in einer Gruppe, die
Mitarbeiter ziemlich nerven können. Neben offensichtlichen Dingen wie Clean Code und
einheitliche Bennung von Dateien, Klassen und Methoden, ist eine Sache die häufiger
im Zusammenspiel zwischen Windows- und Linux-Nutzern stört: Der Zeilenumbruch.&lt;/p&gt;
&lt;p&gt;Im Windows-Universum besitzen Zeilenumbrüche ein CR LF und unter Linux LF. Näheres
zu Zeilenumbrüchen findet sich im entsprechenden &lt;a href=&#34;https://de.wikipedia.org/wiki/Zeilenumbruch&#34;&gt;Wikipedia-Artikel zu Zeilenumbrüchen&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Git Repositorys sollten immer nur LF als Zeilenendung enthalten, da gemischte
Zeilenenden sich auf den Betriebssystemen unterschiedlich auswirken und einfach
unschön in der Handhabung sind. Für Windows-Nutzer
kann beim Auschecken automatisch LF durch CR LF ersetzt werden. Ebenso
sollten immer die CR LF in LF umgewandelt werden, wenn man etwas in das Repository
eincheckt. In der Git für Windows Standard-Installation wird nachgefragt, wie
Zeilenumbrüche gehandhabt werden sollen. Im Standard wird die zuvor beschriebene
automatische Umwandlung vorgeschlagen, die man akzeptieren sollte.&lt;/p&gt;
&lt;p&gt;Nichtsdestotrotz schaffen es einige, solche Optionen abzuwählen und es landen
am Ende Dateien mit gemischten Zeilenenden im Repository was ziemlich unschön ist.
Am „schönsten“ ist es etwa dann, wenn Projekt-Mitarbeiter eine Zeile in einer
Datei ändern, durch die Änderung aber jede Zeile der Datei anpassen und das ohne
weitere Prüfung in das Repository schieben.&lt;/p&gt;
&lt;p&gt;Das ganze lässt sich auf mehreren Weisen verhindern. Prinzipiell hilft es die
Personen natürlich aufzuklären, warum man einheitliche Zeilenumbrüche verwenden
sollte und wie man es konfiguriert. Die Konfiguration für jede Person ist
prinzipiell recht simpel. Dazu muss lediglich der Konfigurationsschalter
&lt;code&gt;core.autocrlf&lt;/code&gt; auf &lt;code&gt;input&lt;/code&gt; gesetzt werden, wenn man unter Linux oder macOS
arbeitet. Unter Windows sollte jedenfalls &lt;code&gt;core.autocrlf&lt;/code&gt; auf &lt;code&gt;true&lt;/code&gt; gesetzt
werden. In dem Fall wird dann die zuvor angesprochene automatische Umwandlung
aktiviert. Die Konfiguration kann entweder in &lt;code&gt;~/.gitconfig&lt;/code&gt; händisch erfolgen
oder man nutzt diesen Befehl:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git config --global core.autocrlf true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dies führt allerdings noch nicht vollständig dazu, dass bestehende Zeilenumbrüche die in
Dateien vorhanden sind, korrigiert werden. Dazu helfen Tools wie &lt;code&gt;dos2unix&lt;/code&gt;, aber
auch Git hilft dabei, wenn man geänderte Dateien neu eincheckt.&lt;/p&gt;
&lt;p&gt;Damit nicht nur die lokale Konfiguration jedes Projekt-Mitarbeiters korrekt
konfiguriert ist, kann man zusätzlich auf das Repository die Einstellungen
durchsetzen. Dazu muss die Datei &lt;code&gt;.gitattributes&lt;/code&gt; im Repository hinterlegt werden,
in dem die Zeile &lt;code&gt;* text=auto&lt;/code&gt; enthalten ist. Nachdem die Datei committet wurde
und/oder die Änderung in der Config steht, meldet Git beim Commiten von Dateien
mit CR LF folgende Meldung:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add chapter02/
warning: CRLF wird in Projektdokumentation/chapter02/cryptdb/02_problem.tex durch LF ersetzt.
Die Datei wird ihre ursprünglichen Zeilenenden im Arbeitsverzeichnis behalten.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend lebt es sich angenehmer, wenn direkt alle Projekt-Mitarbeiter die
korrekte Einstellung nutzen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Binärdateien effizienter in Git-Repositorys nutzen mit Git LFS</title>
      <link>https://svij.org/blog/2017/04/17/binardateien-effizienter-in-git-repositorys-nutzen-mit-git-lfs/</link>
      <pubDate>Mon, 17 Apr 2017 12:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/04/17/binardateien-effizienter-in-git-repositorys-nutzen-mit-git-lfs/</guid>
      <description>&lt;p&gt;Dateitypen, die sich nicht effizient in Git-Repositories nutzen lassen, sind
Binärdateien. Also genau die Dateien, die man nicht mit einem gängigen Texteditor
öffnen kann. Mit Git LFS kann man Binärdateien effizienter verwalten, dabei ist
Git LFS eine Erweiterung für den Git-Client, ein entsprechendes Gegenstück wird
aber auch auf dem Server benötigt.&lt;/p&gt;
&lt;p&gt;Doch bevor man sich Git LFS anschaut, sollte man verstehen, wie Git Dateien
intern abspeichert, um nachvollziehen zu können, warum man eine Lösung wie Git
LFS braucht.&lt;/p&gt;
&lt;h3 id=&#34;git-interna&#34;&gt;Git Interna&lt;/h3&gt;
&lt;p&gt;Diejenigen, die wissen wie Git intern die Dateien verwaltet, können diesen Abschnitt
getrost überspringen.&lt;/p&gt;
&lt;p&gt;Git ist ein verteiltes Versionskontrollprogramm, dementsprechend müssen alle Änderungen,
die im Repository getätigt wurden, auch lokal vorliegen. Git speichert dazu jede
neue oder veränderte Datei einmal komplett im Repository ab. Aus Geschwindigkeitsgründen
werden nicht anwendbare Diffs speichert, sondern eben die kompletten Dateien.&lt;/p&gt;
&lt;p&gt;Konkret heißt es, dass wenn in einem neuen und leeren Repository eine neue Datei
in einem Commit hinzugefügt wird, dann komprimiert Git die Datei und schiebt es
einfach gesagt irgendwo in den &lt;code&gt;.git&lt;/code&gt; Ordner. Wenn reine Textdateien vorhanden sind, was bei
Software-Quellcode durchaus der Fall ist, dann funktioniert das ganz gut, da so wenig
Speicherplatz belegt wird. Wenn die besagte Textdatei verändert wird und die Änderung
in das Repository committed wird, dann speichert Git die Datei ebenfalls komplett
neu ab. Beim Auschecken des Commits davor, muss Git nur die andere Datei
wieder dekomprimieren und in das Arbeitsverzeichnis schieben. Das geht gewöhnlich
recht schnell.&lt;/p&gt;
&lt;p&gt;Jetzt sollte man erkennen, warum man ohne Git LFS Binärdateien nicht verwenden
sollte: Git speichert auch Binärdateien bei jeder Änderung neu im Repository ab.
Da sich Binärdateien meist nicht so effizient komprimieren lassen, wie es bei Textdateien
der Fall ist, ist die Komprimierung nahezu nutzlos.
Bei einer Binärdatei die 50mb groß ist und 10 Mal verändert wurde (jeweils mit
Commits), dann ist ein Repository schon mit etwa 500mb belegt. Je häufiger man
also Binärdateien verändert, desto größer wird das Repository, was demnach auch
viel Platz auf dem Datenträger belegt.&lt;/p&gt;
&lt;p&gt;Und genau hier kommt Git LFS ins Spiel.&lt;/p&gt;
&lt;h3 id=&#34;git-lfs&#34;&gt;Git LFS&lt;/h3&gt;
&lt;p&gt;LFS steht für „Large File Storage“ und ist eine Erweiterung von Git, das betrifft
sowohl den Client als auch den Server. Leider befinden sich für Git LFS keine Pakete
in den Paket-Repositorys der gängigen Linux-Distributionen, weshalb man sich
Git LFS &lt;a href=&#34;https://packagecloud.io/github/git-lfs/install&#34;&gt;via packagecloud.io&lt;/a&gt;
installieren muss.&lt;/p&gt;
&lt;p&gt;Nachdem man sich die Git LFS installiert hat, kann es in den Repositorys genutzt
werden. Wie zuvor erwähnt, braucht der Server auf der Gegenseite ebenfalls
Unterstützung für Git LFS. Das gute ist, dass es die gängigen und bekannten
Git-Hosting-Dienste anbieten. Das betrifft insbesondere GitHub, GitLab, Bitbucket
und Gogs/Gitea.&lt;/p&gt;
&lt;p&gt;Der Einsatz von Git LFS muss in jedem Repository einmal konfiguriert werden.
Dies geht ganz einfach:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git lfs install
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;An dieser Stelle ist noch nicht viel passiert, denn es muss noch konfiguriert
werden, welche Dateien von Git LFS beachtet werden sollen. Wenn man häufiger mit
Bildern hantiert, dann sind es zum Beispiel &lt;code&gt;*.webp&lt;/code&gt; Dateien. Alternativ können
natürlich auch einzelne Dateinamen angegeben werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git lfs track &amp;quot;*.webp&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Git LFS legt dabei die Datei &lt;code&gt;.gitattributes&lt;/code&gt; im Arbeitsverzeichnis ab, die man auf jeden
Fall mit in das Repository schieben muss. Der Inhalt der Datei sieht in diesem
Beispiel so aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;*.webp filter=lfs diff=lfs merge=lfs -text
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann man noch ein Remote-Repository anlegen, was Git LFS unterstützt,
um anschließend JPG-Dateien zu versionieren. Das ganze lässt sich dann auch
einfach testen: Einfach ein (größeres) Bild mit nehmen, es Committen und Pushen
und anschließend die Dateigröße vom &lt;code&gt;.git&lt;/code&gt; Verzeichnis anschauen. Das ganze sollte
man wiederholen und dabei das Bild häufiger anpassen, um mehrere Versionen zu
erzeugen. Wenn man dies tut, dann sieht man recht schnell, dass die Größe des
Repositorys nicht wesentlich zunimmt. In meinen Tests ergab sich aber auch, dass
das lokale Repository manchmal trotzdem größer geworden ist, allerdings werden bei einem
frischen Klon oder beim Pullen nicht alle Versionen der Binärdatei heruntergeladen.&lt;/p&gt;
&lt;p&gt;Git LFS funktioniert somit recht einfach, man muss nur die Dateien bzw Dateitypen
angeben, die von Git LFS getrackt werden sollen. Anschließend kann man wie gehabt
Commits tätigen und Pushen und im Hintergrund arbeitet Git LFS vor sich hin.
Kompliziert ist das ganze dann nicht.&lt;/p&gt;
&lt;h4 id=&#34;funktionsweise&#34;&gt;Funktionsweise&lt;/h4&gt;
&lt;p&gt;Bisher haben wir zwar die Probleme von Binärdateien in Git-Repositorys dargelegt
und gezeigt wie man Git LFS nutzt. Allerdings wurde noch nicht gezeigt, wie
das nun intern im Groben funktioniert. Statt die Binärdatei selbst im Repository
abzuspeichern, speichert Git LFS nur einen Pointer auf die große Datei ab, die
auf den LFS-Server zeigt. Diese Pointer sind dabei recht klein, da es eben
nicht die ganze Binärdatei ist. Bei einem Push werden dann die Binärdateien zum
LFS-Server hochgeladen und das reine Repository vom normalen Git-Server. Beim
Auschecken eines Branches oder eines bestimmten Commits, werden die Versionen
dann im Hintergrund vom LFS-Server geladen und im Arbeitsverzeichnis ersetzt. Somit
werden nur die Binärdateien geladen, wie man zu dem Zeitpunkt wirklich braucht.&lt;/p&gt;
&lt;p&gt;Durch den Einsatz von Git LFS kann man so recht einfach auch Binärdateien verwalten,
verliert dadurch aber auch die Möglichkeit auf alle Revisionen einer Binärdatei
offline zuzugreifen. Da man häufig sowieso online ist, dürfte das meistens kein
allzu großes Problem sein. Nichtsdestotrotz sollte man sich bewusst sein, wann man Git LFS
einsetzt und für welche Dateien bzw. Dateitypen. Idealerweise verwaltet man nämlich
weiterhin in Software-Projekten nur reinen Quellcode. Für große Fotos oder anderen
Binärdateien kann Git LFS aber eine gute Alternative sein.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Mit Git Worktree mehrere Arbeitsverzeichnisse managen</title>
      <link>https://svij.org/blog/2017/04/14/mit-git-worktree-mehrere-arbeitsverzeichnisse-managen/</link>
      <pubDate>Fri, 14 Apr 2017 23:10:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/04/14/mit-git-worktree-mehrere-arbeitsverzeichnisse-managen/</guid>
      <description>&lt;p&gt;In der Regel klont man sich ein Git-Repository, in dem auch ein Arbeitsverzeichnis
eines Branches ausgecheckt ist. Je nach Projektart
kann es passieren, dass eine Arbeitskopie nicht reicht. Das ist etwa dann der Fall,
wenn man ein Projekt kompilieren muss, was eine Zeit in Anspruch nimmt, in derselben
Zeit aber auf einem anderen Branch weiterarbeiten möchte. Im Standard
geht das so mit einem geklonten Repository nicht, da sich beim Wechsel des Branches
das Arbeitsverzeichnis verändert und somit auch die Kompilierung nicht voll
durchläuft bzw. es zu Fehlern kommt.&lt;/p&gt;
&lt;p&gt;Was an dieser Stelle einige machen ist folgendes: Ein weiteren Klon des Repositorys
anlegen und darin weiterarbeiten. Das ist aus gleich mehreren Gründen eine nicht
optimale Option. Zum einen verliert man die ganze Konfiguration eines Git-Repositorys,
darunter fallen insbesondere die Konfiguration von Remote-Repositorys und die
angelegten lokalen Branches und Commits. Bei dem zweiten Klon kann man zwar die
Remote-Repositorys konfigurieren, zwischen rein lokalen Branches zu wechseln
ist dann aber schwieriger. Ein weitere Grund ist der Plattenplatz, da
gleich zweimal das gleiche Repository Platz auf der Festplatte belegt. Bei kleinen Repositorys ist das
vielleicht weniger relevant und verschmerzbar, bei größeren Repositorys kann das aber durchaus
ungünstig sein.&lt;/p&gt;
&lt;p&gt;Eine Lösung für das Problem bietet &lt;code&gt;git worktree&lt;/code&gt;. Mit &lt;code&gt;worktree&lt;/code&gt; lassen sich
mehrere Arbeitsverzeichnisse handhaben, die zu einem Repository gehören. Damit
kann man gleich mehrere Branches in verschiedenen Ordnern auschecken, mit diesen
Arbeiten. Im Endeffekt hat man weiterhin nur ein Repository, in dem alle Revisionen
und Objekte gespeichert sind.&lt;/p&gt;
&lt;h3 id=&#34;mit-worktrees-arbeiten&#34;&gt;Mit Worktrees arbeiten&lt;/h3&gt;
&lt;p&gt;Ein zusätzlicher Worktree kann recht einfach angelegt werden. Der Befehl ist
allerdings vergleichsweise lang. Wenn man sich schon in einem Arbeitsverzeichnis
eines Git-Repositorys befindet, dann reicht folgender Befehl, um einen weiteren
Worktree anzulegen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git worktree add -b fix/0815 ../temp-worktree master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Subbefehl &lt;code&gt;worktree&lt;/code&gt; ist wohl genauso klar, wie der Parameter &lt;code&gt;add&lt;/code&gt; um einen
weiteren Worktree anzulegen. Mit &lt;code&gt;-b fix/0815&lt;/code&gt; gibt man den Namen des neuen Branches
an, der für den Worktree genutzt werden soll – dies ist somit äquivalent zu
&lt;code&gt;git checkout -b fix/0815&lt;/code&gt;. Danach folgt der Pfad, wo der Worktree
lokal hingesetzt werden soll. Zum Schluss noch der Name des Branches, von dem
der neue Branch angelegt werden soll, in diesem Fall einfach &lt;code&gt;master&lt;/code&gt;.&lt;/p&gt;
&lt;p&gt;Das ganze geht auch etwas einfacher, wenn man nicht einen neuen Branch anlegen
möchte:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git worktree add ../fix-4711
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man anschließend in den Worktree wechselt und schaut, auf welchem Branch
man sich befindet, dann ist es der neue Branch &lt;code&gt;fix-4711&lt;/code&gt;. Als Basis-Branch wurde
dafür dann automatisch der aktuelle Branch genommen. Wie man sieht, legt Git-Worktree
dann automatisch den Worktree an dem angegebenen Verzeichnis an und legt den Branch
mit demselben Namen an. Mit &lt;code&gt;list&lt;/code&gt; kann man sich alle Worktrees anzeigen lassen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git worktree list
/home/sujee/Repositories/svijorg       bbc5c37 [master]
/home/sujee/Repositories/fix-4711      bbc5c37 [fix-4711]
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man die Arbeit an einem Worktree abgeschlossen hat und es nicht mehr braucht,
kann man den Worktree einfach entfernen, etwa mit &lt;code&gt;rm&lt;/code&gt;. Anschließend sollte man
nur die Referenz im eigentlichen Repository dann löschen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ rm -rf ../fix-4711
$ git worktree prune
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Die Referenz auf nicht erreichbare bzw. nicht existente Worktrees werden von
der Garbage Collection nach und nach selbst gelöscht. Wenn man allerdings Worktrees
auf potenziell nicht erreichbaren Verzeichnissen ablegt, also auf mobilen oder
Netzwerk-Datenträgern, dann kann man sie auch locken, um ein &lt;code&gt;prune&lt;/code&gt; von der GC
zu verhindern.&lt;/p&gt;
&lt;p&gt;Die übliche Handhabung von Worktress ist sonst wie in einem normalen Repository
auch: Man kann wie gehabt von allen Worktrees aus Branches anlegen, Commits
erzeugen und die Änderungen pushen und pullen.&lt;/p&gt;
&lt;p&gt;Für viele dürfte &lt;code&gt;git worktree&lt;/code&gt; ein Feature sein, dass sie nicht brauchen, für
einige wiederum ist dies doch ein sinnvolles Feature von Git, was man hin und
wieder gebrauchen kann und dabei etwas Arbeit und Zeit spart.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git-Repositorys Hosten mit Gitea</title>
      <link>https://svij.org/blog/2017/04/08/git-repositorys-hosten-mit-gitea/</link>
      <pubDate>Sat, 08 Apr 2017 21:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/04/08/git-repositorys-hosten-mit-gitea/</guid>
      <description>&lt;p&gt;Um Git-Repositorys zu Hosten gibt es heutzutage sehr viele verschiedene Möglichkeiten.
Die einfachste und wohl bekannteste Lösung für viele Open-Source-Projekte ist die Nutzung von GitHub.
GitHub bietet auch das Hosten von privaten, nicht öffentlichen, Repositorys an,
doch ist dies kostenpflichtig. GitHub ist zudem nicht Open Source und man kann
es nicht selbst Hosten. Eine Alternative ist GitLab, welches sowohl als Service
zum kostenfreien Nutzen verfügbar ist, als auch Open Source ist. Auf GitLab.com
kann man im Gegensatz zu GitHub seinen Code in privaten Repositorys schieben, ohne
bezahlen zu müssen. Da GitLab Open Source Software ist, lässt sich die Community Edition
auch auf eigener Hardware selbst hosten. Allerdings ist GitLab vergleichsweise
fett und braucht selbst mit wenigen Nutzern recht viel Arbeitsspeicher, hat dafür aber eine Vielzahl an
Funktionen. Für Firmen und anderen Projekte dürfte GitLab wohl eine gute Wahl sein,
doch ist es für das Hosten von privaten Repositorys für einzelne Personen eher fett, da man die meisten
Features wohl eh nicht braucht. Eine weitere Alternative ist Gogs, bzw. dessen neuer
Fork namens Gitea. Gitea ist ein recht neuer Fork von Gogs, was wiederum ein quasi-Klon
von GitHub ist. Wobei sich der Ausdruck „Klon“ mehr auf das Aussehen und die
grundlegenden Funktionen richtet und somit weniger auf den darunter liegenden
Code.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/gitea_repoview.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/gitea_repoview.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Gitea ist in der Programmiersprache Go geschrieben und ist ein Git-Server der
auch eine Web-Oberfläche daherkommt. Die grundlegenden Features sind dabei ähnlich
zu GitHub und GitLab. So können über die Web-Oberfläche Nutzer angelegt werden,
die dann Git-Repositorys anlegen können. Dabei bietet es auch die Möglichkeit Organisationen
anzulegen, um Repositorys gruppenbezogen anzulegen und zu Verwalten. In diesen
Organisationen können dann noch Teams mit verschiedenen einfachen Berechtigungen
für verschiedene Aufgaben angelegt werden.&lt;/p&gt;
&lt;p&gt;Neben dem reinen Hosten von Git-Repositorys gibt es für die Projekte einen Issue-Tracker
sowie die Möglichkeit Pull-Requests zu erstellen. Die Web-UI beinhaltet weiterhin
die gängigen Funktionen von GitHub-ähnlichen Portalen: Die Anzeige von Branches,
Commits und der Historie aller getätigten Änderungen. Ebenfalls ist eine Wiki-Komponente
enthalten.&lt;/p&gt;
&lt;p&gt;Wie zuvor schon erwähnt ist Gitea ein Fork von Gogs. Letzteres gibt es schon länger,
hat aber über die Zeit ein wesentliches Problem: Es gibt nur einen Maintainer
und dieser ist in der Vergangenheit häufiger mal für ein paar Monate abwesend gewesen.
Andere Leute hatten leider keine Commit-Rechte, weshalb das Projekt einige Monate
inaktiv war, obwohl Contributor da waren, die mitentwickeln wollten. Auch Bug-Reports
und Bug-Fixes blieben dadurch teilweise Monate liegen. Die Contributions-Grafik
des &lt;a href=&#34;https://github.com/Unknwon&#34;&gt;Maintainers&lt;/a&gt; zeigt dieses Problem auch deutlich
dar. Da keine Änderung in Sicht ist und Maintainer auch kein Interesse hat andere
Co-Contributor in das Team aufzunehmen, wurde ein Fork gestartet, was unter dem
Namen Gitea läuft. Der Entwickler von Gogs äußert sich dazu aber positiv, da dies
die Stärke von Open Source Software darstellt und es die gewählte MIT-Lizenz auch
zulässt.&lt;/p&gt;
&lt;h3 id=&#34;installation&#34;&gt;Installation&lt;/h3&gt;
&lt;p&gt;Die Installation von Gitea ist recht simpel. Es gibt aktuell noch keine Pakete
für Linux-Distributionen, die es bei Gogs hingegen gibt. Die händische Installation
von Gitea ist allerdings recht simpel. Die folgende Anleitung geht davon aus,
das ein frisches System vorliegt, sei es in einer virtuellen Maschine oder in
einem System-Container.&lt;/p&gt;
&lt;p&gt;Es bietet sich an einen &lt;code&gt;git&lt;/code&gt; System-Nutzer anzulegen, über dem die Kommunikation
über SSH verläuft, wenn man mit Git hinterher arbeitet. Um Gitea auszuführen, muss
man lediglich eine einzelne Binärdatei herunterladen und ausführen. Unter &lt;a href=&#34;https://dl.gitea.io/gitea/&#34;&gt;dl.gitea.org/gitea&lt;/a&gt;
finden sich die aktuellen Ordner mit den Veröffentlichungen. Aktuell ist beim
Schreiben dieses Artikels die Version 1.1.0. Die Versionsnummern sind dort
etwas irritierend, deshalb lohnt sich ein Blick in die &lt;a href=&#34;https://github.com/go-gitea/gitea/releases&#34;&gt;Releases&lt;/a&gt;,
um die aktuellste Versionsnummer zu ermitteln.&lt;/p&gt;
&lt;p&gt;Nachdem Herunterladen muss die Datei noch ausführbar gemacht werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ wget -O gitea https://dl.gitea.io/gitea/1.1.0/gitea-1.1.0-linux-amd64
$ chmod +x gitea
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann die Datei ausgeführt werden, um die erste Konfiguration durchzuführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ ./gitea web
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Im Web-Browser kann man nun die IP-Adresse des Systems aufrufen, um Gitea über
das Web zu konfigurieren. Die Web-Oberfläche läuft im Standard allerdings auf
Port 3000. Gitea braucht eine Datenbank, die bei der
Installation konfiguriert werden muss. Diese muss man sich zuvor dementsprechend
installieren und die Zugangsdaten bei der Installation angeben.&lt;/p&gt;
&lt;p&gt;Damit man anschließend Gitea nicht über die Kommandozeile immer starten muss, sollte
man einen Service anlegen. Vorlagen dafür liegen im &lt;a href=&#34;https://github.com/go-gitea/gitea/tree/master/contrib&#34;&gt;&lt;code&gt;contrib&lt;/code&gt;&lt;/a&gt;
Verzeichnis des Gitea-Repositorys. Ein passendes systemd Unit-File findet sich
unter &lt;a href=&#34;https://github.com/go-gitea/gitea/blob/master/contrib/systemd/gitea.service&#34;&gt;&lt;code&gt;contrib/systemd/gitea.service&lt;/code&gt;&lt;/a&gt;
bei dem nur wenige Dinge geändert werden müssen. Bei einem Upgrade muss nur noch
das Binary ersetzt werden und der Dienst neugestartet werden.&lt;/p&gt;
&lt;p&gt;Weitere Konfiguration kann über die Ini-Datei erfolgen, die unter &lt;code&gt;custom/conf/app.ini&lt;/code&gt; liegt. Der Pfad ist dabei abhängig vom Installationsort. Wenn man die
Installation als &lt;code&gt;git&lt;/code&gt; Systemnutzer durchgeführt hat und das Binary im Home-Directory liegt, dann liegen alle relevanten Daten demnach im Home-Verzeichnis des
Git-Systemnutzers.&lt;/p&gt;
&lt;h3 id=&#34;systemstatus&#34;&gt;Systemstatus&lt;/h3&gt;
&lt;p&gt;Gitea ist sehr leicht und sparsam, was den Ressourcenverbrauch angeht. Folgende
Daten liefert der System Monitor Status, nachdem der Server in diesem Fall mit
nur einem Benutzer läuft.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/gitea-systemmonitor.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/gitea-systemmonitor.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Dies ist einer der wesentlichen Gründe, weshalb sich der Einsatz von Gitea
vor allem bei kleinen Projekten lohnt. Im Gegensatz zu GitLab ist Gitea und auch Gogs klein
und leicht, lässt sich einfach warten und hat zudem eine einfache Web-Oberfläche
mit diversen Funktionen, die auch GitHub hat, um Repositorys einfach zu Hosten.
Zuvor nutzte ich &lt;a href=&#34;http://gitolite.com/gitolite/index.html&#34;&gt;gitolite&lt;/a&gt;, was aber manchmal etwas anstrengender zu nutzen war,
da man für viele Kleinigkeiten ständig mit Konfigurationsdateien hantieren muss,
etwa dann, wenn man ein Repository anlegen will. Da ist die Konfiguration mittels
einer Web-Oberfläche deutlich komfortabler.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Gitea bietet viele Features die auch in anderen Git-Hosting-Servern verfügbar
sind. Durch den geringen Ressourcenverbrauch bietet es sich besonders für private
Repositorys und kleine Projekte an. Abstriche muss man hingegen trotzdem an den
ein oder anderen Stelle machen, was aber ziemlich normal ist. So sind die Berechtigungsstrukturen
für Organisationen eher einfach umgesetzt und auch an einigen anderen Stellen
müssen wohl Abstriche gemacht werden. Für diese gibt es aber weiterhin GitLab,
was sich größeren Projekten oder Firmen schon besser eignet.&lt;/p&gt;
&lt;p&gt;Auf der Projektseite auf &lt;a href=&#34;https://docs.gitea.io/en-us/&#34;&gt;docs.gitea.io&lt;/a&gt; findet sich
die Dokumentation. Darunter auch mehr Informationen zum Funktionsumfang, dem Upgrade
von Gogs, und alternative Installationsmöglichkeiten.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Statischer Pelican Blog mit statischen Kommentaren</title>
      <link>https://svij.org/blog/2017/03/22/statischer-pelican-blog-mit-statischen-kommentaren/</link>
      <pubDate>Wed, 22 Mar 2017 22:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/03/22/statischer-pelican-blog-mit-statischen-kommentaren/</guid>
      <description>&lt;p&gt;Seit nun mehr drei Jahren läuft mein Blog mit dem statischen Webseiten-Generator
&lt;a href=&#34;https://blog.getpelican.com/&#34;&gt;Pelican&lt;/a&gt;. Einen Artikel zu Pelican hatte ich
&lt;a href=&#34;https://svij.org/blog/2014/07/02/statische-webseiten-mit-pelican-erstellen&#34;&gt;damals auch geschrieben&lt;/a&gt;,
in dem ich die grundsätzlichen Features und Funktionen aufgelistet
habe. Kurz zusammengefasst kann man unter anderem in Markdown Blogposts
schreiben, die von Pelican als HTML-Datei(en) herausgeschrieben werden. Den
„output“ Ordner kann man dann auf beliebigen Webspace schieben. So war bislang
der Umzug des Blogs sehr einfach, da ich nur die generierten Dateien irgendwo
hinschieben musste.&lt;/p&gt;
&lt;p&gt;Ein wesentlicher Nachteil ist von Pelican nur, dass es keine Kommentare erlaubt.
Wie auch, schließlich ist der Blog komplett statisch und soll es eben auch so sein.
Da ich in letzter Zeit vermehrt E-Mails zu meinen Blog-Posts bekommen habe, dessen
Informationen auch für anderen nützlich sein könnten, habe ich mich entschlossen,
eine Kommentarfunktion bereit zu stellen. Externe Dienste wie Disqus kamen für
mich nicht infrage, schließlich lädt das dann wieder externen Content nach und
in meinen Browser werden Dienste wie Disqus auch auf anderen Webseiten
von vorn hinein geblockt. Die Lösung, die ich jetzt einsetze und auf die mich
&lt;a href=&#34;https://c3vo.de/&#34;&gt;Chris&lt;/a&gt; hingewiesen hat, ist das
&lt;a href=&#34;https://github.com/getpelican/pelican-plugins/tree/master/pelican_comment_system&#34;&gt;Pelican Comment System&lt;/a&gt;. Die Handhabung ist
hierbei interessant. Der Kommentator füllt wie gehabt ein Formular aus, der Inhalt
wiederum wird über das lokal installierte E-Mail-Programm an den Blogger gesendet.
Dieser muss dann nur noch die E-Mail in den Code der Webseite schieben, die Seite
neu generieren und dann wieder hochladen. Das ist gleichzeitig praktisch als auch
umständlich. Wesentlicher Vorteil ist, dass der Blogger, in dem Fall ich, die
weiterhin komplett selbst hostet und das Blog auch weiterhin statisch ist.
Nachteilig ist allerdings auch wiederum, dass
dies eine höhere Hürde für Kommentatoren bedeutet. Letzteres empfinde ich gleichzeitig
aber auch als Vorteil, damit nur diejenigen Kommentare abgeben, die auch wirklich
kommentieren wollen.&lt;/p&gt;
&lt;p&gt;Das Verfahren geschieht aktuell noch vollständig händisch. Je nach Aufwand und der
Anzahl der eingehenden Kommentare, lässt sich das mit Skripten automatisieren.
Schließlich muss nur ein Ordner des Postfaches abgerufen werden, die Rohdaten
extrahiert werden, die dann nur noch in das richtige Verzeichnis geschoben werden,
um die Webseite neu zu bauen und hochzuladen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Kurztipp: Latexmk und 16:9 LaTeX Beamer Slides</title>
      <link>https://svij.org/blog/2017/03/18/kurztipp-latexmk-und-169-latex-beamer-slides/</link>
      <pubDate>Sat, 18 Mar 2017 09:40:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/03/18/kurztipp-latexmk-und-169-latex-beamer-slides/</guid>
      <description>&lt;p&gt;Manchmal sind es die kleinen Dinge, die das Arbeiten mit LaTex und in meinem
speziellen Fall LaTeX Beamer vereinfachen. Ein hilfreiches Tool ist etwa
&lt;a href=&#34;https://mg.readthedocs.io/latexmk.html&#34;&gt;Latexmk&lt;/a&gt;. Wer häufiger an LaTeX-Dokumenten
arbeitet, kennt wohl das Problem, dass man den Code mehrfach kompilieren muss,
damit alle Cross-Referenzen aktualisiert werden. Etwa dann, wenn neue Kapitel
hinzugefügt werden, die dann im Inhaltsverzeichnis gelistet werden sollen.
Latexmk macht das ganze etwas schlauer und kompiliert das Dokument gleich
genau so oft durch, wie es nötig ist.&lt;/p&gt;
&lt;p&gt;Das nächste Problem was Latexmk löst ist, dass man bei faktisch jeder Änderung
ein aktualisiertes Dokument haben will. Latexmk besitzt auch einen &amp;ldquo;watch&amp;rdquo; Modus
der bei jeder Änderung, und somit immer dann, wenn man eine Datei speichert, direkt
neu kompiliert.&lt;/p&gt;
&lt;p&gt;Das ganze sieht dann so aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ latexmk -pvc main.tex
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man, wie ich, XeLaTeX nutzt, dann kann man auch einfach &lt;code&gt;-xelatex&lt;/code&gt; als weiteren
Parameter angeben. So muss man anschließend nur noch das Quelldokument verändern
und kann sich die Änderung ein paar Sekunden später mit dem PDF-Viewer seiner Wahl
anschauen.&lt;/p&gt;
&lt;h3 id=&#34;169-latex-beamer-folien&#34;&gt;16:9 LaTeX Beamer Folien&lt;/h3&gt;
&lt;p&gt;Heutzutage haben die meisten neueren Beamer und vor allem Fernseher eine 16:9
Auflösung. Das Standard-Format von LaTeX-Beamer Folien ist nicht 16:9, sondern 4:3.
Das Format lässt sich aber ganz einfach anpassen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;\documentclass[aspectratio=169]{beamer}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Mit &lt;code&gt;aspectratio&lt;/code&gt; kann man das Format angeben, unterstützt werden 1610, 149, 54, 43
und 32. Der Default ist 43. Man sollte bloß beachten, dass die Grafiken „richtig“
eingebunden werden sollten, sodass beim Wechsel zwischen den Formaten die Texte und Grafiken
weiter gut aussehen und nicht über den Rand schießen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git-Historie neu-schreiben (nicht nur) mit Filter-Branch</title>
      <link>https://svij.org/blog/2017/03/16/git-historie-neu-schreiben-nicht-nur-mit-filter-branch/</link>
      <pubDate>Thu, 16 Mar 2017 20:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/03/16/git-historie-neu-schreiben-nicht-nur-mit-filter-branch/</guid>
      <description>&lt;p&gt;Nach längerer Pause zum Thema Versionsverwaltung mit Git geht es an dieser Stelle
ein wenig weiter. Git-Repositorys beinhalten bekanntlich ihre vollständige Historie,
so dass alle Änderungen immer in der Historie verbleiben. Problematisch wird das
aber, wenn Zugangsdaten im Repository gelandet sind. Ein bloßes Entfernen funktioniert
da leider nicht, da die Historie ja vollständig da ist.&lt;/p&gt;
&lt;p&gt;Ein einfaches Beispiel sieht man etwa, wenn man bei GitHub nach &lt;a href=&#34;https://github.com/search?utf8=%E2%9C%93&amp;amp;q=delete+id_rsa&amp;amp;type=Commits&amp;amp;ref=searchresults&#34;&gt;„delete id_rsa“&lt;/a&gt;
sucht, was ein privater SSH-Key ist, der nicht eigentlich in ein Git-Repository landen
sollte. Genauso findet man auf GitHub Commit-Messages mit dem Inhalt &lt;a href=&#34;https://github.com/search?utf8=%E2%9C%93&amp;amp;q=remove+password&amp;amp;type=Commits&amp;amp;ref=searchresults&#34;&gt;„remove password“&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Wenn man die entsprechenden Passwörter oder SSH-Private-Keys ändert bzw. ersetzt,
dann muss man natürlich nicht viel mehr in dem Git-Repository ändern. Anders sieht
es aus, wenn die Datei bzw. die Zeilen vollständig entfernt werden soll. Die Historie
muss dafür (maximal) vollständig angepasst werden, was für jede Person, die mit dem Repository
arbeitet, heißt, dass es vermutlich am einfachsten ist, das Projekt einmal neu zu klonen.&lt;/p&gt;
&lt;p&gt;Abhilfe um gleich eine Vielzahl von Commits anzupassen bietet das Subkommando
&lt;code&gt;filter-branch&lt;/code&gt;. Dies kann nicht nur zum Entfernen von Passwörtern oder anderen
Credentials dienen, sondern auch, wenn etwa große Binärdateien im Repository sind,
die entfernt werden sollen.&lt;/p&gt;
&lt;p&gt;Um das Verfahren auszuprobieren, kann man sich ein einfaches Repository anlegen,
in dem zahlreiche Commits erzeugt werden, um dieses Repository dann aufzuräumen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ mkdir test-repo
$ for i in {1..500}; do echo &amp;quot;Commit $i&amp;quot; &amp;gt;&amp;gt; index; git add -A; git commit -m &amp;quot;Commit $i&amp;quot;; done
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Diese Bash-For-Schleife legt im Test-Repository die Datei &lt;code&gt;index&lt;/code&gt; an und schreibt
in jedem Durchlauf den Durchlaufzähler in die Datei, mit dem Wort &amp;ldquo;Commit&amp;rdquo; vorne
dran. Nach jeder Zeile wird dann ein Commit mit selbigen Inhalt in der Commit-Message
gespeichert.&lt;/p&gt;
&lt;p&gt;Das Repository wäre somit vorbereitet. Filter-Branch hat diverse Filter, die man
anwenden kann. Eines ist etwa der &lt;code&gt;tree-filter&lt;/code&gt;, mit dem man dateibasiert arbeitet.&lt;/p&gt;
&lt;p&gt;Eine einfache Methode eine Datei aus allen Commits wäre es, ein &lt;code&gt;rm -f index&lt;/code&gt;
auszuführen, was in jedem Commit die Datei entfernen würde. Händisch wäre das
ja zu aufwändig, weshalb man folgenden Befehl ausführen kann:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git filter-branch --tree-filter &#39;rm -f index&#39; HEAD
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Statt die Datei zu entfernen, kann man auch Inhalte der Datei verändern, etwa
mit &lt;code&gt;sed&lt;/code&gt;. Dazu muss dann der Befehl entsprechend angepasst werden. Es gibt
auch noch weitere Filter, wie etwa der &lt;code&gt;subdirectory-filter&lt;/code&gt;. Dieser kann genutzt werden,
um ganze Unterverzeichnisse in ein eigenes Repository zu überführen. Die Historie
des restlichen Repositorys wird dabei ignoriert, sofern sie nicht relevant ist.
Wesentlicher Vorteil ist dabei, dass die vollständige Historie eines Subdirectories
erhalten bleibt, sodass man auch nach dem Extrahieren frühere Änderungen
nachvollziehen kann.&lt;/p&gt;
&lt;h3 id=&#34;alternative-bfg-repo-cleaner&#34;&gt;Alternative: BFG Repo-Cleaner&lt;/h3&gt;
&lt;p&gt;Eine Alternative zum reinen Filter-Branch ist der &lt;a href=&#34;https://rtyley.github.io/bfg-repo-cleaner/&#34;&gt;BFG Repo-Cleaner&lt;/a&gt;.
Im Gegensatz zu Filter-Branch ist die Nutzung deutlich einfacher und es soll auch
schneller sein. Das Tool ist in Java geschrieben und besitzt ein paar nette
Features, die man sich bei Filter-Branch erstmal selbst zusammen schreiben müsste.
Ein Beispiel ist etwa die automatische Entfernung von Dateien, die größer sind als eine
spezifizierte Größe. Dazu besitzt bfg den Parameter &lt;code&gt;--strip-blobs-bigger-than&lt;/code&gt;.
Das vorherige Beispiel mit dem Löschen der Datei funktioniert zwar prinzipiell
mit Filter-Branch auch einfach, allerdings beachtet es immer nur den aktuellen
Pfad. Wenn etwa eine oder mehrere zu löschende Dateien im Repository zuvor herum geschoben
wurde, dann hilft bfg mit dem Parameter &lt;code&gt;--delete-files&lt;/code&gt; schon viel mehr, da es
immer die Dateien mit den entsprechenden Namen löscht.&lt;/p&gt;
&lt;p&gt;Für viele dürfte der BFG Repo-Cleaner ein einfaches Interface bieten, um die
Historie vollständig anzupassen und trotzdem viel und auch schneller zu arbeiten.
In der Regel erfolgt die Nutzung von Filter-Branch auch häufig nur einmalig, weshalb
sich einige Sachen nur mit gewissen Aufwand durchführen lassen, die mit BFG einfacher
und wohl auch schneller gehen. Bedacht werden sollte aber immer, dass sehr viele
Commits angepasst werden. Man sollte dies nur tun, wenn es wirklich nötig ist
und auch die Mitarbeiter entsprechend vorher informieren, damit kein bzw. nur kurz
ein kaputtes Repository lokal vorhanden ist!&lt;/p&gt;
&lt;p&gt;Vielen Dank an &lt;a href=&#34;https://www.deimeke.net/dirk/blog/&#34;&gt;Dirk&lt;/a&gt; der mich auf BFG Repo-Cleaner
hinwies. Mehr zu Git findet sich auf meinem Blog in der &lt;a href=&#34;https://svij.org/blog/category/git/&#34;&gt;Git-Kategorie&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Suchen und Finden mit ag, statt ack (statt grep)</title>
      <link>https://svij.org/blog/2017/03/08/suchen-und-finden-mit-ag-statt-ack-statt-grep/</link>
      <pubDate>Wed, 08 Mar 2017 17:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2017/03/08/suchen-und-finden-mit-ag-statt-ack-statt-grep/</guid>
      <description>&lt;p&gt;Vor fast drei Jahren bloggte ich über &lt;a href=&#34;https://svij.org/blog/2014/04/27/suchen-und-finden-mit-ack-statt-grep/#suchen-und-finden-mit-ack-statt-grep&#34;&gt;„Suchen und Finden mit Ack, statt grep“&lt;/a&gt;. Heute lautet der Titel
allerdings „Suchen und Finden mit ag, statt ack“.&lt;/p&gt;
&lt;p&gt;Ag und Ack sind vom Prinzip her gleich: Mit beiden findet man Strings in Dateien,
ähnlich wie es grep auch kann. Im Gegensatz zu grep arbeitet ack und ag schneller
und ist mehr für Programmierer und Sysadmins ausgerichtet, da es diverse unnötige
Verzeichnisse (wie &lt;code&gt;.git&lt;/code&gt;) nicht durchsucht. Auch die Ausgabe ist gleich. Ag ist
hingegen ein Klon von Ack, was in C statt in Perl geschrieben wurde. Der Fokus
bei ag liegt besonders auf die Geschwindigkeit. Wer dachte, dass ack schon schnell
ist, der findet mit ag ein noch schnelleres Tool. Laut Angaben des Projektes ist
es dabei 5-10x schneller als ack.&lt;/p&gt;
&lt;p&gt;Auf meinen Systemen die ich selbst und alleine betreue und nutze, habe ich ack
durch ag ersetzt. Auf Systemen wo ich entweder nicht alleine drauf bin, verbleibt
weiterhin grep das Tool der Wahl, damit man nicht überall alles nachinstallieren muss
und ggf. auch garnicht erst sollte.&lt;/p&gt;
&lt;p&gt;Der Paketname von ag ist nicht direkt nachvollziehbar, sofern man das Periodensystem
der Elemente nicht vollständig kennt. Silber ist nämlich das 47. Element mit dem Symbol &amp;ldquo;ag&amp;rdquo;.
Unter Ubuntu heißt das Paket &lt;code&gt;silversearcher-ag&lt;/code&gt; während es unter diversen
anderen Distributionen einfach &lt;code&gt;the_silver_searcher&lt;/code&gt; heißt.&lt;/p&gt;
&lt;p&gt;Mehr Informationen zu Tools die in diversen Eigenschaften besser als ack sind,
finden sich auf &lt;a href=&#34;http://betterthanack.com/&#34;&gt;betterthanack.com&lt;/a&gt;. Das GitHub-Repository
von mit mehr Informationen findet sich &lt;a href=&#34;https://github.com/ggreer/the_silver_searcher&#34;&gt;hier&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Adblocking auf DNS-Ebene mit dnsmasq</title>
      <link>https://svij.org/blog/2016/12/31/adblocking-auf-dns-ebene-mit-dnsmasq/</link>
      <pubDate>Sat, 31 Dec 2016 17:20:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/12/31/adblocking-auf-dns-ebene-mit-dnsmasq/</guid>
      <description>&lt;p&gt;Auf meinem &lt;a href=&#34;https://svij.org/blog/2016/04/24/homeserver-migration-auf-ubuntu-1604/#homeserver-migration-auf-ubuntu-1604&#34;&gt;Homeserver&lt;/a&gt; laufen einige Dienste die für das
Heimnetzwerk wichtig sind. Das relevante ist dabei der DHCP- und DNS-Server.
Um den Homeserver als DHCP- und DNS-Server zu verwenden, nutze ich &lt;a href=&#34;https://wiki.ubuntuusers.de/Dnsmasq/&#34;&gt;dnsmasq&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Wie der Titel schon verrät, geht es hier um Adblocking auf DNS-Ebene. Die Anfragen
an bekannte Ad- und Tracking-Server sollen bereits über das DNS verhindert werden.
Konkret heißt das, dass wenn eine Domain eines bekannten Werbeanbieters aufgerufen
wird, diese auf &lt;code&gt;127.0.0.1&lt;/code&gt; auflöst. Der wesentliche Vorteil ist, dass das Adblocking
somit nicht mehr in jedem Browser auf jedem Gerät im Netzwerk konfiguriert werden
muss. Während sich dies auf die normalen Rechner mit Desktop-Betriebssystemen
nicht sonderlich auswirkt, hat das einen großen Vorteil bei mobilen Geräten. So
bekommen alle Apps und Browser im Heimnetzwerk einen Adblocker. Nebenbei blocken
einige Adblocker-Blocker einen nicht mehr, wenn man so ein Setting fährt&amp;hellip;&lt;/p&gt;
&lt;p&gt;Auf der Seite &lt;a href=&#34;http://pgl.yoyo.org/adservers/serverlist.php&#34;&gt;pgl.yoyo.org/adservers/serverlist.php&lt;/a&gt; gibt es eine Adserver Liste die regelmäßig aktualisiert wird. Auf
der &lt;a href=&#34;http://pgl.yoyo.org/adservers/&#34;&gt;Hauptseite&lt;/a&gt; gibt es auch ein Formular, um
die Liste im passenden Format für den eingesetzten DNS-Server zu bekommen. Für
dnsmasq ist es etwa dann &lt;a href=&#34;http://pgl.yoyo.org/adservers/serverlist.php?hostformat=dnsmasq&amp;amp;showintro=0&amp;amp;mimetype=plaintext&#34;&gt;folgender Link&lt;/a&gt;. Der Inhalt der Datei muss
anschließend nur noch nach &lt;code&gt;/etc/dnsmasq.d-available/adblock.conf&lt;/code&gt; geschoben werden,
gefolgt von einem Symlink von &lt;code&gt;/etc/dnsmasq.d/adblock.conf&lt;/code&gt; auf die entsprechende
Datei. Da die Liste regelmäßig aktualisiert wird, kann man zusätzlich noch ein
Cronjob oder systemd Timer anlegen, damit die Liste regelmäßig heruntergeladen
wird. Nach einem Neustart von dnsmasq ist dann der Filter auch schon aktiv.
Wer einen solchen Filter auch außerhalb von zuhause nutzen möchte, der kann sich
zusätzlich einen VPN installieren und konfigurieren, um den Traffic durch das Heimnetz
zu tunneln. Mit &lt;a href=&#34;https://pi-hole.net/&#34;&gt;pi-hole&lt;/a&gt; gibt es auch eine (fast) fertige
Lösung, um das DNS-Adblocking mit Hilfe eines Raspberry Pis umsetzen zu können. Getestet
habe ich das allerdings nicht.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Tschüss freiesMagazin!</title>
      <link>https://svij.org/blog/2016/12/04/tsch%C3%BCss-freiesmagazin/</link>
      <pubDate>Sun, 04 Dec 2016 10:50:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/12/04/tsch%C3%BCss-freiesmagazin/</guid>
      <description>&lt;p&gt;Heute Morgen ist die &lt;a href=&#34;http://www.freiesmagazin.de/20161204-dezemberausgabe-erschienen&#34;&gt;letzte Ausgabe&lt;/a&gt; von &lt;a href=&#34;http://freiesMagazin.de&#34;&gt;freiesMagazin&lt;/a&gt; erschienen. Ich habe
mich selbst nochmal mit einem letzten Artikel &lt;a href=&#34;https://svij.org/blog/2016/12/04/automatisierung-mit-jenkins-20/&#34;&gt;über Jenkins 2.0&lt;/a&gt; verewigt.&lt;/p&gt;
&lt;p&gt;Es ist schade, dass das Projekt nun eingestampft wird, es war aber auch schon
vor einigen Jahren absehbar, dass die Aktivität immer weiter abnahm. Ich selbst
war von Herbst 2012 bis Herbst 2013 für etwa ein Jahr im Redaktionsteam, was ich
aus Zeitgründen damals dann verließ. Ich blieb aber bis zur letzten Ausgabe
mehr oder weniger regelmäßiger Autor, mit Beginn im Jahr 2011. Was nun auch fünf
Jahre sind.&lt;/p&gt;
&lt;p&gt;An dieser Stelle möchte ich mich an das Team hinter freiesMagazin bedanken. Neben
meiner Mitarbeit und dem Team von ubuntuusers.de habe ich bei freiesMagazin ebenfalls
sehr viel gelernt und auch viel Zeit investiert, die sich definitiv gelohnt hat.
Sorry an Dominik, dass ich manchmal nicht ganz der schnellste war, aber beim Nachhaken,
wo denn die versprochenen Artikel und Rezensionen bleiben, war ich nicht der einzige. ;)
Ohne freiesMagazin hätte ich zudem wohl nie &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/&#34;&gt;mein Git Buch&lt;/a&gt; geschrieben, was auf die Git-Tutorium
Teile aus &lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2014-12&#34;&gt;Teil 1 in freiesMagazin 12/2014&lt;/a&gt;, &lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2015-01&#34;&gt;Teil 2 in freiesMagazin 01/2015&lt;/a&gt;, &lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2015-02&#34;&gt;Teil 3 in freiesMagazin 02/2015&lt;/a&gt; und mit etwas Verzug &lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2015-06&#34;&gt;Teil 4 in 06/2015&lt;/a&gt;
fußt.&lt;/p&gt;
&lt;p&gt;Also ja, mit mehr oder weniger einfachen Arbeiten die man bei Open-Source-Projekten
erledigt, kann man auch beruflich sinnvoll nutzen. Nicht nur als Referenz, dass man
was in Open-Source-Projekten tut, sondern auch mit den Kenntnissen die man durch
die Arbeit gewonnen hat. Deshalb kann ich nur ermutigen: Macht mit! Egal ob Coden,
Schreiben oder Supporten. Was am Ende bei rum kommt, kann jedenfalls nicht schaden.
Der erste Anlaufspunkt, den ich nur empfehlen kann, ist &lt;a href=&#34;https://ubuntuusers.de&#34;&gt;ubuntuusers.de&lt;/a&gt;. Vor allem beim Newsblog &lt;a href=&#34;https://ikhaya.ubuntuusers.de/&#34;&gt;Ikhaya&lt;/a&gt; kann man einfach
mitmachen. Entweder die &lt;a href=&#34;https://ikhaya.ubuntuusers.de/suggest/new/&#34;&gt;„Artikel vorschlagen“-Funktion&lt;/a&gt; nutzen oder beim &lt;a href=&#34;https://wiki.ubuntuusers.de/ubuntuusers/Ikhayateam/UWR/Mitmachen/&#34;&gt;Ubuntu-Wochenrückblick&lt;/a&gt; mitmachen. Die &lt;a href=&#34;https://wiki.ubuntuusers.de/Mitmachen/&#34;&gt;Mitmachen-Seite&lt;/a&gt; im Wiki zeigt auch noch weitere Möglichkeiten, wie man Mitmachen kann.
Mich kann man bei Fragen zum Mitmachen natürlich auch anschreiben!&lt;/p&gt;
&lt;p&gt;In dem Sinne: Danke und Tschüss freiesMagazin! Es war schön, dass es das Magazin
gab, und es ist schade, dass es nun zu Ende geht!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Automatisierung mit Jenkins 2.0</title>
      <link>https://svij.org/blog/2016/12/04/automatisierung-mit-jenkins-20/</link>
      <pubDate>Sun, 04 Dec 2016 09:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/12/04/automatisierung-mit-jenkins-20/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://jenkins.io/&#34;&gt;Jenkins&lt;/a&gt; ist eine vielgenutzte Software, welche im
Zusammenhang mit kontinuierlicher Integration von Software zur
Automatisierung eingesetzt wird. Jenkins wurde im Frühjahr 2016 in der
Version 2.0 freigegeben, wodurch sich der Fokus vom reinen CI-Server zum
generellen Automation Server änderte.&lt;/p&gt;
&lt;p&gt;In &lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2013-01&#34;&gt;freiesMagazin 01/2013&lt;/a&gt;
wurde Jenkins bereits im Bezug zur kontinuierliche Integration behandelt. Der Fokus in
diesem Artikel liegt weniger auf das Thema Kontinuierliche Integration,
sondern mehr auf die Neuerungen die in Version 2.0 Einzug hielten.&lt;/p&gt;
&lt;p&gt;Dieser Artikel erschien auch in der allerletzten &lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2016-12&#34;&gt;freiesMagazin Ausgabe 12/2016&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;jenkins-ci-1x&#34;&gt;Jenkins-CI 1.x&lt;/h3&gt;
&lt;p&gt;Bevor es an die Neuerungen von Jenkins 2.0 geht, erfolgt zuvor noch eine
Einführung in die wesentlichen Elemente und Funktionen, die sowohl in
Jenkins-CI 1.x als auch in Jenkins 2.0 verfügbar sind. Jenkins ist ein Tool,
womit sich viel automatisieren lässt. Es wird am häufigsten im Rahmen der
kontinuierlichen Integration genutzt, um regelmäßig das Software-Projekt zu
bauen, zu testen und ein Release-Paket zu schnüren.&lt;/p&gt;
&lt;p&gt;Einfach ausgedrückt ist Jenkins eine Oberfläche, womit sich regelmäßige
Aktionen verwalten und ausführen lassen. Man könnte fast sagen, dass es eine
aufgeblähte Cron-Oberfläche ist, aber das stimmt natürlich so nicht ganz.&lt;/p&gt;
&lt;p&gt;In Jenkins lassen sich sogenannte Jobs definieren, dessen Hauptbestandteil
häufig Shell-Skripte sind. Ein solcher Jenkins-Job teilt sich in sechs Teile
auf. Der erste Teil sind die allgemeinen Einstellungen des Jobs, in denen
etwa der Name und eine Beschreibung des Jobs spezifiziert werden kann. Der
zweite Teil ist das Source-Code-Management. Dort wird angegeben, an welchem
Ort der Code des Projektes liegt. Jenkins unterstützt nativ und durch den
Einsatz diverser Plug-ins zahlreiche Versionskontrollsysteme wie CVS,
Subversion und auch Git. Es lassen sich sowohl die Quelle angeben, als auch
mögliche Branches, die ausgecheckt werden sollen.&lt;/p&gt;
&lt;p&gt;Nachdem man diese beiden Einstellungen getätigt hat, folgt die eigentliche
Konfiguration des Builds. Wie zuvor erwähnt, kann man Jenkins auch ein wenig
mit Cron vergleichen, da regelmäßig Jobs ausgeführt werden können. Wie und
wann die Jobs ausgeführt werden, kann im Build-Auslöser Schritt definiert
werden. Ein einfache Möglichkeit ist die Ausführung zu bestimmten Uhrzeiten,
diese verwendet sogar die Cron-Syntax. Damit lassen sich etwa Nightly-Builds
umsetzen, bei denen die Jenkins-Jobs einmal in der Nacht ausgeführt werden.
Alternativ ist es ebenfalls möglich bei jedem neuen Commit das Projekt zu
bauen oder im Nachgang eines Vorgänger-Jenkins-Jobs.&lt;/p&gt;
&lt;p&gt;Der eigentliche Ablauf wird im Buildverfahren abgebildet. Dies sind häufig
Shell-Skripte unter Linux- und BSD-Systemen und Batch unter Windows. Durch
den Einsatz von Plug-ins lassen sich einige Build-Schritte im
Build-Verfahren auch ohne Skripte lösen, das kommt dann jeweils auf die
Projekt-Art und Programmiersprache an. Statt Skripte sind dort dann
Formular-Felder enthalten, die man ausfüllen muss. Im Build-Verfahren wird
bei einem Software-Projekt häufig das Projekt zuerst gebaut und anschließend
die geschriebenen Tests ausgeführt. Sofern bei beiden Schritten kein fataler
Fehler auftritt, sollten die Test-Ergebnisse als XML-Dateien
herausgeschrieben werden, die in den Post-Build-Aktionen von Jenkins
ausgewertet werden. Das ist somit auch der letzte Schritt, bei dem nicht nur
die Test-Auswertung stattfinden kann, sondern die Ergebnisse auch per
Jabber, E-Mail oder sonstigem Kommunikationsmittel versandt werden können.&lt;/p&gt;
&lt;p&gt;Im definierten und ausgeführten Job kann man nach der Ausführung des Jobs
den Status sehen. Falls das Projekt erfolgreich gebaut und die Tests
fehlerfrei ausgeführt wurden, ist der Status des Jobs „Erfolgreich“, was mit
einer blauen Kugel dargestellt wird. Auch gelbe bei instabilen Jobs mit
einigen fehlgeschlagenen Tests oder rote Kugeln bei fehlgeschlagenen Jobs
sind möglich. Der Job zeigt mehr oder weniger übersichtlich an, welche Tests
fehlschlagen sind, seit wann diese Tests fehlschlagen und auch einen
übersichtlichen Graphen mit der Anzahl und Ergebnisse der Tests.&lt;/p&gt;
&lt;p&gt;Jenkins lässt sich vielfältig einsetzen und das nicht nur zur Ausführung von
Builds und Tests von Projekten. Die größte Stärke liegt in den zahlreichen
Erweiterungsmöglichkeiten mittels Plug-ins. Jenkins-Jobs laufen auf einem
Jenkins-Knoten – welche auch häufig Jenkins-Slaves oder Build-Executors
genannt werden – und diese können auf allen gängigen Betriebssystemen
laufen, da letztendlich fast nur Java auf den Slaves gebraucht wird.&lt;/p&gt;
&lt;p&gt;Jenkins hat immer zwei aktuelle Versionen: eine LTS-Version und eine normale
Version. Die normale Version folgt einem wöchentlichen Rhythmus und ist die
„Bleeding Edge“-Version. Diese sollte man nicht im produktiven Einsatz
verwenden, da dort häufig noch viele Fehler enthalten sind. Stattdessen
sollte man lieber zur LTS-Version greifen, die einen stabilen Stand
darstellt und alle drei bis vier Monate auf Basis der Nicht-LTS-Version
gebaut wird. Je nachdem, wie intensiv man Jenkins nutzt, passiert es auch
schnell, dass viele Funktionen in Plug-ins genutzt werden, die nochmal
separat aktualisiert werden müssen. Dafür gibt es auch eine eigene
Plug-in-Verwaltung, die installierbare und aktualisierbare Plug-ins auflistet.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/jenkins-overview.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/jenkins-overview.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Jenkins 1.x hatte einige Nachteile, die in Jenkins 2.0 ausgemerzt werden
sollten. Ein Punkt war, dass die initiale Konfiguration von Jenkins durchaus
zeitaufwendig und wenig intuitiv war. In der Standard-Installation war der
Server nämlich komplett offen und frei zugänglich. So konnte jeder ohne
irgendeine Authentifizierung Jobs anlegen und auf dem Server laufen lassen.
Die Absicherung mit Vergabe von passenden Rechten war für Jenkins-Einsteiger
eher schwierig und umständlich, was den Einstieg deutlich erschwerte.&lt;/p&gt;
&lt;p&gt;Ein weiterer wesentlicher Nachteil von den oben vorgestellten „Free
Style“-Jenkins-Jobs ist, dass die Konfiguration der Jobs vollständig auf dem
Jenkins-Master gespeichert ist. Die Jobs sind aber in der Regel abhängig von
dem Code, der im Source-Code-Management-System hinterlegt ist. Einzelne Teil
der Job-Konfiguration ließen sich zwar im Repository speichern und
ausführen, aber eben nicht alles und schön war dies auch nicht sonderlich.
Das Problem ist insbesondere, dass keine Versionierung erfolgte und man über
die Zeit gegebenenfalls keine älteren Stände mittels Jenkins bauen konnte,
außer, wenn die alten Jobs gesichert wurden. Das war in der Regel wenig
komfortabel und wurde über die Zeit meist unübersichtlich.&lt;/p&gt;
&lt;p&gt;Außerdem war auch die Konfiguration von Jenkins-Jobs mit steigender
Komplexität von Projekten immer aufwändiger. Wenn man etwa in einem Projekt
mehrere Branches hatte, bei denen die gleichen Jobs mit einigen Änderungen
ausgeführt werden sollten, dann musste der Job mehrfach kopiert werden und
bei Änderungen, die jeden Job betrafen, musste jeder Job einzeln angepasst
werden. Das machte die Jenkins-Konfiguration weder einfach, noch machte es
Spaß. Diese drei Punkte waren die wesentlichen Punkte, die in Jenkins 2.0
verbessert werden sollten.&lt;/p&gt;
&lt;h3 id=&#34;jenkins-20&#34;&gt;Jenkins 2.0&lt;/h3&gt;
&lt;p&gt;Jenkins 2.0 erschien im Frühjahr 2016. Die erste LTS-Version 2.7 erfolgte
ein paar Monate später im Sommer. Jenkins wurde vom CI-Server zum reinen
Automation Server umgenannt, da Jenkins schon länger nicht mehr nur als
reiner CI-Server diente. Auch die URL des Projektes änderte sich von
jenkins-ci.org zu &lt;a href=&#34;https://jenkins.io/&#34;&gt;jenkins.io&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Viele Nachteile und Umständlichkeiten wurden in Jenkins 2.0 verbessert. Das
wohl größte Feature ist die Nutzung von sogenannten „Pipelines“, die als
Code in einer Datei gespeichert und mit dem restlichen Code des Projektes
versioniert werden. Diese Features wurden größtenteils in Plug-ins
implementiert, die getrennt vom eigentlichen Jenkins aktualisiert werden.
Pipelines sollen nicht nur bei der Continuous Integration unterstützten,
sondern auch beim Continuous Delivery, also beim Ausliefern und Ausrollen
von Software.&lt;/p&gt;
&lt;p&gt;Die ursprünglich komplett offene Basis-Installation wurde dadurch
abgesichert, indem beim ersten Start von Jenkins sich zuerst ein
Einrichtungsassistent öffnet, der nicht nur Basis-Plug-ins zur Installation
anbietet, sondern auch einen Nutzer-Account erstellt und die Rechte
entsprechend setzt.&lt;/p&gt;
&lt;p&gt;Weitere nützliche Features sind die Einführung des „GitHub Organization
Plugin“ und des „Multibranch-Pipeline“. Aber dazu später mehr.&lt;/p&gt;
&lt;h4 id=&#34;pipeline-as-code&#34;&gt;Pipeline as Code&lt;/h4&gt;
&lt;p&gt;„Pipeline as Code“ wird das Verfahren genannt, womit die komplette
Konfiguration eines Jenkins-Jobs in einer Datei geschrieben werden kann.
Eine Pipeline kann man als Workflow ansehen, bei dem verschiedene Schritte
ausgeführt werden, um Dinge zu erledigen. Das beinhaltet bei einem
Software-Projekt etwa das Bauen, Testen und ggf. auch das Veröffentlichen
und Deployen der Software.&lt;/p&gt;
&lt;p&gt;Das Skript wird in Groovy geschrieben und in der Regel mit dem Dateinamen
&lt;code&gt;Jenkinsfile&lt;/code&gt; im Repository abgespeichert. Alleine das Versionieren im
Repository bringt schon einen Vorteil, so kann ohne Probleme ein älterer
Stand des Repositorys ausgecheckt werden und das Projekt in Jenkins mit der
damaligen Konfiguration gebaut werden. Bei der Nutzung von Jenkins ohne
Pipelines war dies nicht möglich, da die Skripte separat im Job definiert
wurden und in der Regel nicht mit dem Projekt synchronisiert wurden.&lt;/p&gt;
&lt;p&gt;Mit einem Jenkinsfile soll die komplette Konfiguration eines oder mehrerer
Jobs in einem Jenkinsfile zusammenfließen. Wo man vorher ggf. mehrere
einzelne Jobs definiert hat, die verschiedene Dinge erledigen, kann das nun
in einer Pipeline und somit in einem Jenkins-Job geschehen. Pipelines haben
aber auch noch weitere Vorteile, so können Pipelines beliebig pausiert
werden und auch einen Neustart des Jenkins-Masters „überleben“ – egal, ob es
geplant oder ungeplant war. Dies ist insbesondere bei Updates nützlich, denn
Updates von Jenkins selbst und der Jenkins-Plug-ins erfordern einen Neustart
des Dienstes, was nur geht, wenn keine Jobs laufen oder diese sich pausieren
lassen. Bei kleinen Jenkins-Installationen, bei denen nur wenige Jobs
definiert sind und nur selten Jobs angestoßen werden, ist das wohl kein
großer Vorteil. Bei großen Installation mit zahlreichen parallel laufenden
Jobs schon eher.&lt;/p&gt;
&lt;p&gt;Um mit Pipelines sinnvoll arbeiten zu können, gibt es drei Begriffe die
bekannt sein müssen: Steps, Nodes und Stages. Ein Step ist nicht viel mehr
als eine Task, die einen Teil einer Ausführung darstellt. Sie sagt Jenkins
quasi, was zu tun ist. Nodes sind generell die vorher bekannten
Jenkins-Slaves, also Rechner, auf denen Jenkins-Jobs ausgeführt werden
können. Im Pipeline-Kontext haben diese eine etwas andere zusätzliche
Bedeutung. In einem Jenkinsfile können ein oder mehrere Node-Blöcke
definiert werden. Jeder Node-Block wird zur Jenkins-Build-Queue hinzugefügt,
wodurch diese an passende Nodes verteilt werden. Dort wird dann zusätzlich
der Workspace vorbereitet, in dem häufig auch das Repository geklont bzw.
ausgecheckt wird. So kann man in einem Jenkinsfile beispielsweise hundert
Nodes definieren, die gegen einen zentralen Server Requests schicken und die
Antworten auswerten. Dies ging vorher zwar schon mit
Multikonfigurationsprojekten, doch war es dort auch etwas umständlicher.&lt;/p&gt;
&lt;p&gt;Der letzte Teil ist ein Stage. Eine Pipeline kann aus mehreren Stages
bestehen, die eigene Aufgaben erledigen. Um das Beispiel mit dem Bauen und
Testen eines Software-Projektes fortzuführen, kann man etwa drei Stages
definieren: einen zum Bauen, einen zum Testen und eine zur Testauswertung
des Projektes. Die Stages werden auch noch schöner im Job definiert, sodass
man sieht wie lange ein Stage in etwa dauert und ob dort etwas schief
gegangen ist.&lt;/p&gt;
&lt;h5 id=&#34;eine-pipeline-schreiben&#34;&gt;Eine Pipeline schreiben&lt;/h5&gt;
&lt;p&gt;Bislang wurde rein die Theorie der Pipeline behandelt. Spannender wird es,
wenn eine Pipeline geschrieben wird. Voraussetzung ist eigentlich nur, dass
ein Jenkins-Server mit dem Pipeline-Plug-in installiert ist. Anschließend
muss über das Hauptmenü &lt;code&gt;Element anlegen&lt;/code&gt; eine Pipeline ausgewählt werden,
die dann ein passenden Pipeline-Job anlegt. Für den Anfang ist es immer
besser, die Pipeline innerhalb eines Jobs zu definieren, statt sie direkt in
ein Repository zu legen, da sonst sehr häufig bei Änderungen für Kleinigkeiten
eingecheckt werden muss.&lt;/p&gt;
&lt;p&gt;Das folgende Beispiel zeigt eine ganz einfache Pipeline, die nicht viel mehr
macht als die Ausgabe von „Hello World!“:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;node {
  echo &#39;Hello World!&#39;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dieses zugegeben einfache Beispiel führt auf einem beliebigen Node zur
Ausgabe von „Hello World!“. Man kann &lt;code&gt;node&lt;/code&gt; auch noch einen Parameter
übergeben, welcher den Namen des Nodes darstellt, auf dem der Code
ausgeführt werden soll. Das sieht etwa so aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;node(&amp;quot;ubuntu1604&amp;quot;) {
  echo &#39;Hello World from Ubuntu!&#39;
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Damit das auch ausgeführt wird, muss allerdings ein Node existieren, mit dem
Namen oder Label &lt;code&gt;ubuntu1604&lt;/code&gt;. Ansonsten wartet die Pipeline ewig, bis ein
solcher Node verfügbar ist.&lt;/p&gt;
&lt;p&gt;An dieser Stelle wäre es zwar möglich die theoretisch die komplette Pipeline-Syntax
herunterzuschreiben, allerdings wäre das wohl etwas viel. Ein
wichtige Quelle um die richtige Syntax zu lernen und alle Funktionen zu finden,
ist der „Snippet Generator“. Dieser ist in jedem Pipeline-Job zu finden, wenn man
im Hauptmenü auf &lt;code&gt;Pipeline Syntax&lt;/code&gt; klickt.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/pipeline-syntax-menue.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/pipeline-syntax-menue.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Dort findet sich ein Drop-Down-Menü, in dem sich verschiedene Build-Schritte
und Aktionen über diverse Formulare zusammengeklickt werden können. Dies ist
sehr oft sehr hilfreich, weil man auch nach längeren Arbeiten mit der
Pipeline-Syntax sich diese nicht so einfach einprägen kann. Das liegt auch
daran, dass viele Plug-ins ihre eigenen Befehle und Parameter mitbringen,
die man sich fast unmöglich merken kann. Ansonten gilt, dass der Code in
Groovy geschrieben wird und dessen Sprachelemente ebenfalls genutzt werden
können.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/pipeline-snippetgenerator.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/pipeline-snippetgenerator.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Interessant werden Pipelines, wenn mehrere Stages existieren, welche die
Ausführung der Pipeline sinnvoll gruppieren:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;node {
  stage(&#39;Checkout&#39;) {
    checkout scm
  }

  stage(&#39;Build&#39;) {
    sh &#39;&#39;&#39;cmake .
      make -j2&#39;&#39;&#39;
  }

  stage(&#39;Tests&#39;) {
    sh &#39;./run_tests&#39;
  }
}
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Durch die Umsetzung der Jobs in Pipelines wurden viele Nachteile aus Jenkins
1.x ausgebessert. Einige Features sind allerdings noch nicht – oder nur
anders – mit Pipelines möglich. So lassen sich aktuell etwa keine Stages
innerhalb von Stages schachteln. Es existiert auch keine direkte
Möglichkeit, um Multikonfigurationsprojekte umzusetzen. Letzteres sind Jobs,
die mit verschiedenen Konfigurationen ausgeführt werden, also etwa Tests
einer Software mit verschiedenen Einstellungen. Dies ist etwa dann
notwendig, wenn man die Software über verschiedene Linux-Distributionen oder
gar Betriebssystemen hinweg testet, und trotzdem noch übersichtlich sehen
will, ob ein bestimmtes System noch Probleme hat.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/pipeline-stages.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/pipeline-stages.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Je nachdem wie intensiv man Jenkins nutzt, kann es also durchaus sein, dass
sich noch nicht alle bisherigen Jobs in Pipelines umsetzen lassen. Da muss
man wohl noch auf einige weitere Features und Verbesserungen warten.
Pipelines bilden trotzdem die wesentliche Grundlage für die zukünftige
Nutzung von Jenkins. Sie sind nicht unbedingt einfach zu schreiben, lassen
sich durch die Nutzung des Snippet-Generators trotzdem mit vielen kleinen
Schritten schreiben. Pipelines sind auch wesentlicher Bestandteil der
nächsten drei Funktionen, die vorgestellt werden.&lt;/p&gt;
&lt;h5 id=&#34;multibranch-pipeline&#34;&gt;Multibranch-Pipeline&lt;/h5&gt;
&lt;p&gt;Ein weiterer Nachteil bei Jenkins 1.x war, dass man für so gut wie jeden
Branch einen eigenen Job brauchte, wenn dieser gebaut und getestet werden
sollte. Dadurch, dass man ein Jenkinsfile geschrieben hat, liegt die
Konfiguration des Jobs schon im Repository, was an dieser Stelle einfach
genutzt werden kann für jeden Branch, den man haben möchte. Theoretisch kann
man auch weiterhin einzelne Jobs für einzelne Branches anlegen, die dann
jeweils das Jenkinsfile anlegen. Aber auch das wäre eher umständlich, da
nicht benötigte Entwicklungsbranches mit ihren Jobs immer wieder gelöscht
werden müssen. Hier kommt das Multibranch-Pipeline-Plug-in ins Spiel. In dem
Job definiert man nur, welches Repository eingelesen werden soll.
Anschließend scannt Jenkins das komplette Repository, um alle Branches mit
einem Jenkinsfile zu finden. Daraus erzeugt Jenkins dann dynamisch eigene
Jobs, was viel Konfigurations- und Wartungsarbeit verhindert. Bei gelöschten
Branches löscht Jenkins automatisch auch den dynamisch generierten Job.&lt;/p&gt;
&lt;p&gt;Wesentlicher Nachteil dieser Lösung ist, dass jedes Repository einzeln
konfiguriert werden muss. Dafür gibt es aber auch eine Lösung, jedenfalls
für GitHub.&lt;/p&gt;
&lt;h5 id=&#34;github-organization-folder-plugin&#34;&gt;GitHub Organization Folder Plugin&lt;/h5&gt;
&lt;p&gt;Das „GitHub Organization Folder Plugin“ geht das Problem an, dass man für
jedes Repository ein eigenen Job anlegen muss, wovon dann die Jenkinsfiles
eingelesen werden. Mit diesem Plug-in wird nicht nur ein Repository, sondern
die ganze GitHub-Organisation gescannt. Jenkins legt dann einen Ordner an,
in dem alle Repositorys mit allen Branches, die ein Jenkinsfile enthalten,
aufgelistet werden. Weiterhin konfiguriert Jenkins ebenfalls das
automatische Bauen bei Pull-Requests. Zuvor muss Jenkins die entsprechenden
Rechte für die GitHub-Organisation gegeben werden, damit dieser den
Pull-Request auslesen darf. GitHub-Organisation umfasst dabei nicht nur die
Organisationen von GitHub, sondern auch normale Benutzer-Accounts.&lt;/p&gt;
&lt;p&gt;Das Plug-in erleichtert die Einrichtung von GitHub-Repositorys einer
Organisation in Jenkins deutlich, da eine Konfiguration von einzelnen
Repositorys und Pull-Requests nicht notwendig ist. Dies ist im Zusammenhang
mit der erleichterten initialen Einrichtung ein weiteres Feature, was die
Konfiguration und Administrierung deutlich erleichtert, da das meiste
automatisch und dynamisch erzeugt wird.&lt;/p&gt;
&lt;p&gt;Leider gibt es diese Funktion nur für GitHub. Für andere Git-Hostingdienste
ist es leider nicht verfügbar, könnte aber theoretisch mit den nötigen
Kenntnissen selbst implementiert werden, wenn APIs auf der Gegenstelle
verfügbar sind.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/github-org.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/github-org.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;h4 id=&#34;blue-ocean&#34;&gt;Blue Ocean&lt;/h4&gt;
&lt;p&gt;Die Web-Oberfläche von Jenkins funktioniert zwar prinzipiell, ist allerdinga an
vielen Stellen nicht besonders benutzerfreundlich und auch nicht mehr auf Höhe
der Zeit. Blue Ocean nennt sich das Projekt, welches eine neue, frische und moderne
Oberfläche für Jenkins bringen soll und speziell für Pipelines optimiert ist.&lt;/p&gt;
&lt;p&gt;Zur Zeit befindet sich Blue Ocean in einer Beta-Phase für die erste Version
und kann noch recht wenig. Blue Ocean wird wie so vieles von Jenkins in
Plug-ins entwickelt und ausgeliefert. Im Moment kann es vor allem eins: Jobs
alphabetisch auflisten und den Build-Status mit Konsolen-Ausgaben von
Pipelines übersichtlich darstellen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/blueocean-branches.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/blueocean-branches.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Für den alltäglichen Betrieb stößt man bei Blue Ocean schnell an seine
Grenzen, da vieles nicht möglich oder noch nicht zur Verfügung steht. Allen
vorran lassen sich keine administrative Dinge erledigen. Das betrifft nicht
nur die Jenkins-Server-Konfiguration, sondern auch die Konfiguration und das
Anlegen von Jobs. In Zukunft werden in Blue Ocean mehr und mehr Funktionen
einfließen – und dabei nicht nur Funktionen der altbewährten Oberfläche.
Später sollen sich Pipelines auch einfacher und hübscher über Blue Oceans
anlegen lassen. Bis es allerdings soweit ist, dürfte es noch einige Zeit
dauern. Immerhin läuft Blue Ocean unter einer eigenen URL und lässt sich
parallel zum Standard installieren und nutzen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/blueocean-pipeline.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/blueocean-pipeline.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Mit Jenkins 2.0 wurden einige Neuerungen eingeführt, die das tägliche Nutzen
von Jenkins angenehmer gestalten und einige neue Nutzungsmöglichkeiten
bringen. Mit Blue Ocean wird zudem an einer frischen Oberfläche gearbeitet,
die Einiges angenehmer und hübscher macht. Es gibt allerdings auch viele
Alternativen wie &lt;a href=&#34;https://about.gitlab.com/gitlab-ci/&#34;&gt;GitLab CI&lt;/a&gt; oder
&lt;a href=&#34;https://travis-ci.org/&#34;&gt;Travis-CI&lt;/a&gt;, die auch einzelne Vor- und Nachteile
jeweils haben.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>UbuCon Europe in der Retrospektive</title>
      <link>https://svij.org/blog/2016/11/27/ubucon-europe-in-der-retrospektive/</link>
      <pubDate>Sun, 27 Nov 2016 12:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/11/27/ubucon-europe-in-der-retrospektive/</guid>
      <description>&lt;p&gt;Letztes Wochenende fand die erste UbuCon Europe statt. Die UbuCon ist eine
Ubuntu-Konferenz die an verschiedenen Orten auf der Welt stattfindet, so zum
Beispiel auch in Deutschland. Die UbuCon Europe war die erste der Art, die sich
an die internationale europäische Ubuntu Community richtete. Ich selbst war seit 2012
auf jeder deutschen UbuCon, seit 2013 im Orga-Team und seit 2015 Hauptorganisator
für die UbuCon 2015 in Berlin und der UbuCon Europe 2016 in Essen.&lt;/p&gt;
&lt;p&gt;Was alles auf der UbuCon Europe geschah, habe ich bereits in einem &lt;a href=&#34;https://ubuntuusers.de/ikhaya/7853/&#34;&gt;Artikel auf ikhaya.ubuntuusers.de&lt;/a&gt; geschrieben. Das kann man also
da nachlesen. Dieser Artikel geht mehr auf meine persönlichen Erfahrungen bei der
Organisation und der Teilnahme ein.&lt;/p&gt;
&lt;p&gt;Die initiale Idee eine europäische UbuCon auszurichten stammt von &lt;a href=&#34;https://plus.google.com/u/0/+MarcosCostales/posts/jLzUVbFmHuv&#34;&gt;Costales&lt;/a&gt; die wir dann im UbuCon Team
aufgegriffen haben und daraus die UbuCon Europe in Essen formten. Das Unperfekthaus in
Essen war zwar Plan B, allerdings auch nur, weil dort höhere Kosten herrschten.
Sonst hatten wir meist kostenlos zur Verfügung gestellte Räume in Schulen oder
Universitäten bekommen. Im Nachhinein war es sehr gut, dass wir die Veranstaltung
im Unperfekthaus ausgerichtet haben, da es schließlich ein interessanter Ort ist und
das hat sehr vielen Leuten gefallen. Aus organisatorischer Sicht war es ebenfalls einfacher,
so mussten wir vom Orga-Team uns nicht um das Essen und die Getränke kümmern. Im
Gegenteil, diesmal gab es sogar nicht nur stumpf belegte Brötchen und Sandwiches,
sondern gleich richtige Mahlzeiten als Büffet. Auch das WLAN wurde vom Unperfekthaus
gestellt und das funktioniert auch sehr gut, das waren wir schon von unseren
vorherigen Konferenzen gar nicht mehr gewohnt.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubucon2016_audience.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/ubucon2016_audience.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Eine Sorge, die ich am Anfang hatte war, dass fast nur Deutsche erscheinen und
nur wenige Leute aus dem Ausland den Weg nach Essen antreten. Am Ende wurden wir allerdings
positiv überrascht: Es kamen Teilnehmer aus 17 Ländern und drei Kontinenten.
Insgesamt kamen 132 Teilnehmer, wovon 55 % Deutsche waren. Die Zahl war geringer
als wir erwartet haben, da sonst auch in etwa 120 Personen zu unseren rein deutschen
UbuCons kamen. Geschadet hat es hingegen nicht. Auch hier fehlte leider die Zeit
mit jeden sich zusammenzusetzen, um zu quatschen!&lt;/p&gt;
&lt;p&gt;Bei den Talks war auch ein guter Mix zwischen Einsteiger- und Fortgeschrittenen-Themen
vorhanden. Schön war auch, dass Canonical CEO Jane Silber meiner Einladung für
eine Keynote gefolgt ist und den Samstagmorgen auch anwesend war. Neben ihr waren
auch noch ein paar Canonical-Mitarbeiter da und natürlich auch zahlreiche weitere von der Community. Die Slides und ein paar wenige Aufnahmen der Talks sind auf der &lt;a href=&#34;http://ubucon.org/en/events/ubucon-europe/talks/&#34;&gt;Webseite&lt;/a&gt; verlinkt.&lt;/p&gt;
&lt;p&gt;Da bleibt fast nur noch das übrig, was nicht richtig oder gut funktioniert hat.
Prinzipiell hat – recht überraschend – das meiste gut funktioniert. Einzig bei
der Bezahlung und der Kommunikation mit Besuchern und Speakern gibt es
Verbesserungspotenzial, denn da war vielen nicht klar, wann wer wie viel und wo zahlen muss. Am Ende
hat es aber dann doch noch ganz gut geklappt. Das Social-Event am Samstag-Abend
war letztendlich auch nicht ganz so gut besucht wie erwartet. Von 140 interessierten
kamen dann doch nur 80 Leute. Da hatte ich eher mit 100 gerechnet.&lt;/p&gt;
&lt;p&gt;An dieser Stelle möchte ich mich noch bei einigen Personen für die gute Unterstützung
und Hilfe im Team bedanken. Zunächst an David Planella, Daniel Holbach, Alan Pope
und Michael Hall von Canonicals Community-Team die bei Fragen und Anregungen immer
da waren und stets unterstützt haben. Weiterhin gilt mein Dank an Ilonka O. und
Marius Quabeck die mit mir jede Woche beim Meeting mit dem Community-Team teilgenommen
haben und ebenfalls einiges an Arbeit und Ideen eingebracht haben. Nicht zu vergessen
weiterhin Jonathan Liebers und Jens Holschbach welche die UbuCon überhaupt erst
nach Essen gebracht haben, auch wenn der ursprüngliche Plan nicht geklappt hat.
Mein Dank gilt auch Veit Jahns, der mit Ilonka sich um die eingehenden Talks
der Speaker gekümmert hat. Weiterhin natürlich noch Sarah, Peter und Philipp vom
ubuntuusers.de Team die zur falschen Zeit am falschen Ort standen und dann spontan
vor Ort die Arbeit am Registration Desk übernommen haben ;). Last but not least
natürlich noch Torsten Franz und Thoralf Schilde und dem ubuntu Deutschland e.V.
die das ganze finanzielle und rechtliche getragen und unterstützt haben. Falls
ihr die UbuCon und andere Tätigkeiten des ubuntu Deutschland e.V.s unterstützen wollt, dann
&lt;a href=&#34;http://verein.ubuntu-de.org/node/46&#34;&gt;kann man ganz einfach dem Verein beitreten&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Unabhängig vom eigentlichen Orga-Team gilt der Dank natürlich noch den Speakern
und Besuchern die erst das Programm und die Veranstaltung Inhalt gegeben haben!&lt;/p&gt;
&lt;p&gt;Nächstes Jahr findet die UbuCon Europe in Paris statt. Die französische Ubuntu
Community ist sehr aktiv und ich bin schon sehr gespannt was sie da aus dem Hut
zaubern werden. Ob eine deutsche UbuCon nächstes Jahr stattfindet, ist hingegen noch nicht
klar.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Verteiltes Backup-Konzept mit Borg</title>
      <link>https://svij.org/blog/2016/11/12/verteiltes-backup-konzept-mit-borg/</link>
      <pubDate>Sat, 12 Nov 2016 19:40:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/11/12/verteiltes-backup-konzept-mit-borg/</guid>
      <description>&lt;p&gt;In den letzten Wochen habe ich mein verteiltes Backup-Konzept umgesetzt, das ich
in diesen Blogpost beschreiben werde. Ziel war es alle wichtigen Daten mehrfach
und verteilt gesichert zu haben. Und das heißt nicht nur auf verschiedenen Rechnern
im selben Haus, sondern auch &amp;ldquo;in der Cloud&amp;rdquo;. Dann natürlich verschlüsselt.&lt;/p&gt;
&lt;p&gt;Prinzipiell folge ich den &lt;a href=&#34;https://blog.stefan-betz.net/2011/8/22/datensicherung-backups/&#34;&gt;8 goldenen Backup-Regeln von Stefan Betz&lt;/a&gt;.
Insbesondere Regel 2 und 3 sind wichtig:
Man hat mindestens zwei Backups der Daten und nicht gesicherte Daten sind nicht wichtig.&lt;/p&gt;
&lt;p&gt;Insgesamt habe ich drei verschiedene Rechner die Daten haben: Ein Desktop-Rechner,
ein Laptop und ein Homeserver. Der Homeserver läuft immer durch, während der Laptop
und der PC nicht durchgängig laufen. Sowohl der Homeserver als auch der PC sollten
alle Daten besitzen, während der Laptop die Daten auch vom Homeserver beziehen kann.
Demnach dient der Homeserver auch als Datenserver per NFS. Dies ist wichtig für
das Planen des Backups.&lt;/p&gt;
&lt;p&gt;Vor dem Erstellen der initialen Backups ist es erst einmal wichtig alle Daten
aufzuräumen. Ich habe etwa etliche Daten gelöscht, die ich eh nicht mehr brauchte
und auch doppelte Daten gelöscht, die sich in verschiedenen Ordnern versteckt
haben. Mein Home-Directory existiert auch schon seit über fünf Jahren, da versteckt
sich übrigens auch sehr viel alter Kram in versteckten Ordnern, die ebenfalls
einige Gigabyte an Platz belegen können. Nach dem Aufräumen gab es dann für mich zwei
Arten von Daten: Daten die wichtig sind und Daten die nicht wichtig sind. Nicht
wichtige Daten sind Daten, die ich mir andersweitig wieder besorgen kann. Also
sowas wie ISO-Images von Linux-Distributionen oder auch Dinge wie Filme. Diese
müssen nicht gesichert werden. Anders
sieht es aber mit Daten aus die wirklich fast nur ich selbst hatte: Jahr(zehnt)e
alte digitale Fotos, Urlaubsvideos, Dokumente (etwa Zeugnisse) usw. Die wichtigen
Daten beschränken sich bei mir auf gerade einmal 300 GB. Davon geht das meiste auf
die Fotos und Videos drauf. Da hängen schließlich sehr viele Erinnerungen dran,
die ich nicht verlieren will.&lt;/p&gt;
&lt;p&gt;Insgesamt ergaben sich einige Anforderungen die mein Backup-Konzept umfassen
sollte:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Verteilt (im und außerhalb des Hauses)&lt;/li&gt;
&lt;li&gt;Verschlüsselt (auf Dateisystemebene und/oder pro Datei)&lt;/li&gt;
&lt;li&gt;Versioniert (über Monate/Jahre)&lt;/li&gt;
&lt;li&gt;automatisiert&lt;/li&gt;
&lt;li&gt;muss mit Linux tools laufen (Windows ist nicht im Einsatz)&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Als Backup Tool griff ich zum Kommandozeilentool &lt;a href=&#34;https://borgbackup.readthedocs.io/en/stable/&#34;&gt;BorgBackup&lt;/a&gt;.
Das Tool ist nicht nur schnell, sondern kann auch einfach
Daten verschlüsseln und komprimieren. Versionierung wird auch
unterstützt und auch das nachträgliche Löschen von einzelnen Versionsständen ist
möglich. Es gibt zwar viele verschiedene Backup-Tools, aber Borg bot für mich recht
schnell ein gutes Feature-Set, was sich mit wenigen und einfach verständlichen
Kommandos bedienen lässt. Auch die Doku ist modern und aufgeräumt, sodass man da
vieles schnell findet. Ich wollte nämlich definitiv nicht ein Backup-Tool verwenden,
wo ich nicht ganz verstehe wie das funktioniert oder was zu kompliziert ist. Denn
sonst hat man schnell das Problem, dass man beim Einspielen des Backups vor
Problemen steht. Im Wiki von ubuntuusers.de gibt es übrigens seit kurzem auch eine
&lt;a href=&#34;https://wiki.ubuntuusers.de/BorgBackup/&#34;&gt;Dokumentation&lt;/a&gt; auf Deutsch.&lt;/p&gt;
&lt;p&gt;Beim Erstellen des initialen Backups mit Borg habe ich die &lt;a href=&#34;https://borgbackup.readthedocs.io/en/stable/quickstart.html#repository-encryption&#34;&gt;Verschlüsselung&lt;/a&gt; mittels eines
&amp;ldquo;keyfiles&amp;rdquo; gewählt. Auch mit der &lt;a href=&#34;https://borgbackup.readthedocs.io/en/stable/quickstart.html#backup-compression&#34;&gt;Kompression&lt;/a&gt; habe ich etwas vorher getestet und mich letztendlich
für zlib,9 entschieden, was nicht allzu viel Zeit in Anspruch nahm und auch eine
angenehme Kompression bot. Stefan hat sich die verschiedenen Kompressionsstufen
näher angeschaut und festgestellt, dass LZ4 deutlich schneller die Kompression
durchführt und nur wenig mehr Platz auf der Festplatte verbraucht. Näheres findet
sich in &lt;a href=&#34;https://blog.stefan-betz.net/2016/11/12/borgbackup-lzma-zlib-und-lz4-im-vergleich/&#34;&gt;seinem Blogpost&lt;/a&gt;.
Ich verbleibe trotzdem bei zlib, da sich die initiale Kompression schon lange durch
ist und die inkrementellen Backups sowieso nur wenige Minuten dauert, da sich
nicht sehr viele Daten verändern.&lt;/p&gt;
&lt;p&gt;Borg wird von den beiden Clients – dem PC und dem Laptop – ausgeführt und speichert
diese direkt auf dem Homeserver, wo ebenfalls Borg läuft. Vom PC läuft zusätzlich
ein regelmäßiger rsync auf den Homeserver der nackten Daten, damit dieser weiterhin
als Fileserver dienen kann. Die Daten liegen so gesehen dann doppelt auf dem
Homeserver: Einmal ohne irgendwelche Kompression und Verschlüsselung und einmal
in dem Borg Archiv. Der komplette Aufbau sieht wie folgt aus:&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/backup-concept.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/backup-concept.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Mein Rechner führt per eingerichteten systemd-timer 10 Minuten nach dem ersten Boot
an einem Tag das Skript aus, was rsync aufruft und ein neues inkrementelles Borg
Backup durchführt. Da sich meist nicht so viel ändert, geht das in der Regel
recht zügig. Da der Laptop meist außerhalb des Heimnetzes aktiv ist, ist dort
kein systemd-Timer eingerichtet, dort mache ich es in der Regel händisch, dort
liegen aber zumeist auch selten wichtige Daten drin, da notwendigen Daten sowieso
über Git-Repositorys und Nextcloud synchronisiert werden.&lt;/p&gt;
&lt;p&gt;Im wöchentlichen rotierenden Rhythmus werden zusätzlich die USB Backup-Platten
befüllt. Die Platten selbst sind nicht verschlüsselt, da das Borg-Archiv schon
verschlüsselt ist. Damit sind die In-House Backups schon abgehandelt. So liegen
die Daten auf vier verschiedenen Datenträgern verteilt: auf dem PC, dem Homeserver
und den beiden Backup-Platten. Im Falle eines Hardware-Defekts an einem Gerät
ließe sich das Backup relativ einfach wieder einspielen und im minimalen Fall
sind Daten von einem Tag verloren.&lt;/p&gt;
&lt;p&gt;Was trotzdem noch fehlt ist ein Offsite-Backup. Es gibt verschiedene Cloud-Anbieter
die Backup-Systeme anbieten. Zu den bekannteren zählt wohl &lt;a href=&#34;https://aws.amazon.com/de/glacier/&#34;&gt;Amazon Glacier&lt;/a&gt;. Dies wollte ich zu Beginn auch verwenden, da die Kosten von
0,007 USD pro GB und Monat nicht hoch sind. Allerdings ist AWS von der Benutzerführung
schrecklich und auch die Kosten sind schwierig zu berechnen, wenn man Daten
wiederherstellen muss, das auch wieder Geld kostet. Ein kurzer Test meinerseits
brachte mir die Erkenntnis, dass ich das aus komplizierten Preis- und Nutzungsstruktur
nicht verwenden wollte. Eine Alternative war &lt;a href=&#34;https://cloud.google.com/storage/archival/&#34;&gt;Google Archival Cloud Storage&lt;/a&gt;. Dort kostet die Archivierung im &amp;ldquo;Coldline&amp;rdquo; ebenfalls
0,007 USD pro GB und Monat. Da gab es nur ein völlig anderes Problem: Google bietet
die Cloud Dienste nur für Geschäftskunden in Deutschland an - Privatkunden bleiben
somit komplett außen vor. Das ist in anderen Ländern nicht so, da man in den USA
etwa auch als Privatperson sich ein Google Cloud Platform Konto klicken darf.
Eine weitere Alternative war dann der eher kleine Anbieter &lt;a href=&#34;https://www.backblaze.com/&#34;&gt;Backblaze&lt;/a&gt; aus den USA. Dort kostet das &lt;a href=&#34;https://www.backblaze.com/cloud-storage&#34;&gt;B2 Cloud Storage&lt;/a&gt; sogar nur 0,005 USD pro GB und Monat. Ein Download der Daten kostet
dort ebenfalls ungefähr so viel. Im Gegensatz zu Amazon Glacier kriegt man die
Daten auch recht schnell wieder heruntergeladen, da man hier nicht 3-4h warten muss,
bis das Backup zum Download wieder bereitsteht. Backblaze bietet auch ein
&lt;a href=&#34;https://github.com/Backblaze/B2_Command_Line_Tool&#34;&gt;Command Line Tool&lt;/a&gt; an, was
Open Source ist. Womit die Daten hochgeladen werden können. Dies ist ein Python Pip
Paket, was sich recht einfach in einem Virtualenv installieren und nutzen lässt.&lt;/p&gt;
&lt;p&gt;Wichtig bei einem Offsite-Backup war es mir, dass es verschlüsselt ist, so dass
ich es auch bei einem der Cloud-Backup-Provider ohne große Bedenken hochladen konnte.
Das initiale Backup mit Borg hat übrigens etwa 7h gedauert. Das anschließende
Hochladen zu Backblaze über einen Uplink von 40 Mbit/s hat dann nochmal etwa 18h in
Anspruch genommen. Für Leute mit schmalen Uplink ist so ein Upload natürlich
leider nichts.&lt;/p&gt;
&lt;h3 id=&#34;was-fehlt&#34;&gt;Was fehlt?&lt;/h3&gt;
&lt;p&gt;Eins fehlt noch: das vollständige Restore des Backups. Das habe ich noch
nicht getestet, da das doch noch etwas mehr Zeit in Anspruch nimmt. Und ich bin mir
ziemlich sicher, dass da einige Aspekte noch nicht vollständig gesichert sind, sodass
ich an alle meine Daten wieder heran komme, wenn das Haus mit allen Geräten im schlimmsten
Fall abbrennt. Da stellen sich sogar gleich mehrere Fragen:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;Habe ich alle Login-Daten für Online-Dienste gesichert? (Keepassx Backup!)&lt;/li&gt;
&lt;li&gt;Habe ich alle 2FA-Tokens? (Smartphone kaputt und/oder Backup-2FA-Codes im Backup wäre ungünstig)&lt;/li&gt;
&lt;li&gt;Habe ich das Keyfile des Borg-Archivs separat gesichert? (Im Backup das File zu haben, um das Backup zu entschlüsseln, wäre auch ungünstig)&lt;/li&gt;
&lt;li&gt;und vermutlich noch viele weitere Fragen&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Ein gutes Backup-Konzept bringt letztendlich nichts, wenn man es nicht wiederherstellen
kann. ;)&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Persönliches Terminal-Setup</title>
      <link>https://svij.org/blog/2016/11/01/pers%C3%B6nliches-terminal-setup/</link>
      <pubDate>Tue, 01 Nov 2016 10:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/11/01/pers%C3%B6nliches-terminal-setup/</guid>
      <description>&lt;p&gt;Manchmal fragen mich Leute, was ich denn genau für ein Terminal-Setup habe. So
unter anderem auch ein Azubi auf der Arbeit der mich schlicht fragte: &amp;ldquo;Dein
Terminal sieht so toll aus, was nutzt du da (alles)?&amp;rdquo;. So toll sieht es zwar
nicht aus, aber hier mal mein Setup, damit ich das in Zukunft nur noch verlinken
muss.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/terminal-setup.webp&#34; data-lightbox=&#34;image&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/terminal-setup.webp&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;&lt;strong&gt;Terminal-Emulator&lt;/strong&gt;: Als Terminal-Emulator verwende ich hauptsächlich zwei
KDE-Anwendungen: &lt;a href=&#34;https://wiki.ubuntuusers.de/Konsole/&#34;&gt;Konsole&lt;/a&gt; und &lt;a href=&#34;https://wiki.ubuntuusers.de/Yakuake/&#34;&gt;Yakuake&lt;/a&gt;. Yakuake kommt dort zum Einsatz, wenn ich auf kleinen
Displays bin – wie am Laptop – und Konsole auf großen Displays.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Terminal Fenstermanager&lt;/strong&gt;: Früher hatte ich eine Zeit lang &lt;a href=&#34;https://wiki.ubuntuusers.de/Screen/&#34;&gt;screen&lt;/a&gt; verwendet mit einer eigenen Konfiguration, später dann &lt;a href=&#34;https://wiki.ubuntuusers.de/tmux/&#34;&gt;tmux&lt;/a&gt;. Letzteres ebenfalls mit eigener Konfiguration. Nach einer
Weile hat mich das ständige Frickeln an meiner eigenen Konfiguration genervt,
sodass ich auf &lt;a href=&#34;https://wiki.ubuntuusers.de/byobu/&#34;&gt;byobu&lt;/a&gt; umgestiegen bin. Byobu
ist letztendlich nur ein Wrapper um screen oder tmux und hat im Standard schon
eine Leiste unten, wo nicht nur die geöffneten Terminal-Fenster aufgelistet werden,
sondern auch CPU-Auslastung, Uptime, Temperatur, Akku-Prozentanzeige, Uhrzeit
und vieles mehr dargestellt werden. Durch das Drücken der F9-Taste lassen sich
viele weitere Status-Notifications aktivieren und deaktivieren. Praktisch ist
auch, dass zumindest ab Ubuntu 16.04 byobu vorinstalliert ist. In anderen
Distributionen ist es allerdings teilweise gar nicht erst in den offiziellen
Paket-Quellen enthalten.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Shell&lt;/strong&gt;: Als Shell nutze ich &lt;a href=&#34;https://wiki.ubuntuusers.de/Zsh/&#34;&gt;zsh&lt;/a&gt; allerdings
ohne große eigene Konfiguration.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Prompt&lt;/strong&gt;: Viel wichtiger als der Einsatz von zsh oder Bash ist für mich jedoch
&lt;a href=&#34;https://github.com/nojhan/liquidprompt&#34;&gt;liquid prompt&lt;/a&gt;. Dazu hatte ich vor
drei Jahren einen eigenständigen &lt;a href=&#34;https://svij.org/blog/2013/09/07/liquid-prompt/&#34;&gt;Blog-Artikel&lt;/a&gt; verfasst. Mittlerweile wurde das auch weiter entwickelt, sodass ich es jetzt
vor allem schätze, dass bei jedem Befehl auch &lt;code&gt;time&lt;/code&gt; ausgeführt wird, sodass man
schnell sieht, wie lange eine Aktion gedauert hat. Im wesentlichen ist mir da
allerdings die Integration von Git sehr hilfreich, wenn ich täglich damit arbeite.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Jenkins 2.0 Talk auf der committerconf 2016</title>
      <link>https://svij.org/blog/2016/10/18/jenkins-20-talk-auf-der-committerconf-2016/</link>
      <pubDate>Tue, 18 Oct 2016 22:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/10/18/jenkins-20-talk-auf-der-committerconf-2016/</guid>
      <description>&lt;p&gt;Am 17. und 18. Oktober 2016 fand im Essener Unperfekthaus die dritte &lt;a href=&#34;https://committerconf.de&#34;&gt;committerconf&lt;/a&gt;
statt. Ich selbst war zum ersten Mal da, durch den relativ kurzen Anfahrtsweg und
der verfügbaren Zeit war es zum Glück relativ einfach möglich.&lt;/p&gt;
&lt;p&gt;Die committerconf ist im Gegensatz zu den anderen Open Source Konferenz die ich
sonst besuche eine kommerzielle Veranstaltung. Ein normales Ticket kostet da 400€,
dementsprechend waren die Besucher auch eher welche die das Ticket von ihrem Arbeitgeber
bezahlt bekommen haben. Die Konferenz verfolgt ein interessantes Konzept: Jeder der
ein Ticket kauft, bekommt &amp;ldquo;Punkte&amp;rdquo;, die an eingereichten Talks vergeben werden können. Je nach
dem ob Talks gehört werden wollen, werden die Talks kurz vorher angenommen.&lt;/p&gt;
&lt;p&gt;Ich selbst hatte einen Talk eingereicht mit dem Titel &amp;ldquo;Automation mit Jenkins 2.0&amp;rdquo;
wo ich zunächst einen Einstieg in Jenkins (1.x) gegeben habe, gefolgt von den
neuen Features die Jenkins 2.0 eingeflossen sind. Die Slides des Talks habe
ich auf &lt;a href=&#34;https://speakerdeck.com/svij/automation-mit-jenkins-2-dot-0&#34;&gt;Speakerdeck&lt;/a&gt;
hochgeladen. Wer den Talk noch live sehen will: Den werde ich schon bald am 5. November
auf der &lt;a href=&#34;http://programm.openrheinruhr.de/2016/events/458.de.html&#34;&gt;OpenRheinRuhr&lt;/a&gt;
halten, gefolgt von der &lt;a href=&#34;http://ubucon.org/en/events/ubucon-europe/talks/#jenkins&#34;&gt;UbuCon Europe&lt;/a&gt;
am 19. November. Die OpenRheinRuhr findet wieder in Oberhausen statt, die UbuCon Europe ebenfalls
im Unperfekthaus in Essen. Beide Veranstaltungen kann ich nur empfehlen, letzteres
nicht nur (oder vor allem?), weil ich es organisiere. ;)&lt;/p&gt;
&lt;script async class=&#34;speakerdeck-embed&#34; data-id=&#34;d9d6d99cbe204e5891600a80507bffc7&#34; data-ratio=&#34;1.33333333333333&#34; src=&#34;//speakerdeck.com/assets/embed.js&#34;&gt;&lt;/script&gt;
&lt;p&gt;Zurück zur committerconf: Die Besucheranzahl war mit geschätzt 40 Leuten
vergleichweise klein, dafür konnte man umso mehr mit vielen verschiedenen Leuten
sprechen und sich austauschen. Auch das &lt;a href=&#34;https://committerconf.de/2016/schedule&#34;&gt;Programm&lt;/a&gt;
war eher übersichtlich. Nichtsdestotrotz konnte ich einiges neues lernen, vor allem
in den Einsteiger-Workshops zu Vim (nicht im Programm gelistet) und systemd, wo
ich eigentlich dachte, ich hätte genug &amp;ldquo;Einsteigerwissen&amp;rdquo;. So kann man sich irren! ;)&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ein Buch mit Open und Closed Source Software schreiben</title>
      <link>https://svij.org/blog/2016/08/03/ein-buch-mit-open-und-closed-source-software-schreiben/</link>
      <pubDate>Wed, 03 Aug 2016 15:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/08/03/ein-buch-mit-open-und-closed-source-software-schreiben/</guid>
      <description>&lt;p&gt;Wie ich in meinem vorherigen Blog-Post schrieb, habe ich ein &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/&#34;&gt;Buch über Git&lt;/a&gt;
geschrieben, dass seit kurzem erhältlich ist. Mehr Informationen zum Buch selbst,
findet sich im verlinkten &lt;a href=&#34;https://svij.org/blog/2016/08/03/mein-git-buch-beim-mitp-verlag-ist-da/&#34;&gt;Blog-Artikel&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;In diesem Blog-Post soll es um die Tools und Programme gehen, die ich genutzt
habe, um das Buch zu schreiben. Dabei beziehe ich allerdings ausdrücklich nur auf
die Programme, die ich bei mir genutzt habe und nicht die Programme die beim Verlag
im Einsatz waren. Ich habe zwar versucht nur Open Source Software zu nutzen, um
mein Buch zu schreiben, allerdings war das nicht so möglich, wie ich es mir gehofft habe.
Dazu später aber mehr!&lt;/p&gt;
&lt;h2 id=&#34;das-schreiben&#34;&gt;Das Schreiben&lt;/h2&gt;
&lt;p&gt;Insgesamt umfasst das Buch mit allem drum und dran 272 Seiten. Zu Beginn der
Arbeit an dem Buch war vor allem eins wichtig: Das Schreiben möglichst
vieler Wörter und Sätze. Um die Formatierung habe ich mich zu Beginn noch gar nicht
gekümmert, da zunächst eh erstmal der Inhalt grob stehen sollte. Da mein Buch
auf mein &lt;a href=&#34;https://svij.org/blog/category/git/&#34;&gt;bisher vierteiliges Git-Tutorial&lt;/a&gt; basiert, war
das Grundkonzept schon gegeben.&lt;/p&gt;
&lt;p&gt;Zu Beginn brauchte ich ein Textverarbeitungsprogramm das möglichst
wenig ablenkt, darunter fallen auch so Sachen wie Wortvervollständigungen.
Es sollte außerdem die Generierung von PDF-Dateien ermöglichen, damit ich sehen kann, wie viel Inhalt
in etwa schon geschrieben wurde. Außerdem wollte die Quelldateien einfach versionieren,
bei einem Buch über Git ganz überraschend mit Git! ;-)&lt;/p&gt;
&lt;p&gt;Als Textverarbeitungsprogramm wollte ich daher ein simplen Text-Editor nutzen, es
wurde letztlich im wesentlichen &lt;a href=&#34;www.vim.org&#34;&gt;vim&lt;/a&gt;. Den Text habe ich dazu
in Markdown geschrieben, was ich anschließend mit &lt;a href=&#34;http://pandoc.org&#34;&gt;Pandoc&lt;/a&gt;
in PDF-Dateien konvertiert habe. Die Größe und Positionierung von Grafiken habe
ich zu dem Zeitpunkt sowieso noch nicht weiter beachtet. Das Verfahren hat soweit
auch gut funktioniert: Ich konnte mich um den Inhalt kümmern, wurde nicht von
(überladenen) Textverarbeitungsprogrammen genervt und konnte es einfach versionieren.
Meine Zeilen habe ich soweit meistens auf 80 bis 90 Zeichen pro Zeile begrenzt.&lt;/p&gt;
&lt;p&gt;Soweit ich alleine gearbeitet hatte, war der Einsatz von vim mit Markdown und Pandoc
keine Einschränkung für mich. In Zusammenarbeit mit dem Verlag musste der Inhalt
allerdings in eine Microsoft Office oder LibreOffice Writer Dokumentenvorlage überführt werden.
Ich wählte hier LibreOffice Writer, die Vorlage wurde vom Verlag geliefert und
beinhaltete im wesentlichen Formatierungen, damit der Satz vom Verlag durchgeführt
werden konnte. Das Zusammenspiel von LibreOffice in Austausch mit Microsoft Office (auf Seiten des Verlages)
funktioniert erstaunlicherweise gut mit nur ganz wenigen Komplikationen. Das war
ein Punkt, den ich so nicht erwartet hatte. Dabei wurde im wesentlichen die Korrektur-
und Stichwortverzeichnis-Funktion verwendet.&lt;/p&gt;
&lt;h2 id=&#34;die-grafiken&#34;&gt;Die Grafiken&lt;/h2&gt;
&lt;p&gt;Kein Fachbuch kommt ohne Grafiken aus. In meinem &lt;a href=&#34;https://svij.org/blog/category/git/&#34;&gt;Git-Tutorial im Blog&lt;/a&gt;
hatte ich nur wenige Grafiken. Zu Beginn erstmal gar nichts und später zu meist
Screenshots von Git-Programmen, die eine Historie darstellen. Das sah dann etwa so aus:&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-master.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die aktuellen Commits auf dem Master-Branch.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-master.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Für ein Blog war das zwar noch okay, für ein Buch wollte ich das allerdings nicht
haben, so fehlten etwa zusätzliche Informationen, es war wenig flexibel und
klein war die Darstellung auch noch.&lt;/p&gt;
&lt;p&gt;Ein Ersatz musste also her. Ich brauchte sowohl Grafiken für die Darstellung
der Git-Historie, als auch etwa zur Veranschaulichung von Remote-Repositories. Es
gibt zwar Tools die ein Git-Repository grafisch darstellen können, doch ist es
meist wenig flexibel, insbesondere wenn man etwa Unterschiede zwischen Fast-Forward-Merges
von anderen Merge-Strategien darstellen wollte.&lt;/p&gt;
&lt;p&gt;Zunächst schien &lt;a href=&#34;http://www.graphviz.org/&#34;&gt;Graphviz&lt;/a&gt; das passende Tool für mich
zu sein. Es ist Open Source und man schreibt den Code in Textdateien, aus denen
dann die Grafiken erzeugt werden können. In der Theorie las sich das zwar
praktisch, für meinen Einsatzzweck war es allerdings noch nicht so praktisch,
wie ich nach einigen Stunden herausfinden durfte. Wesentlicher Grund war, dass
Graphviz bei die Blasen mit Text frei bewegt, so wie es passt. So war eine
geradlinige Git-Historie recht einfach darstellbar, sobald man mehrere Branches
mit gleichen Git-Objekten untereinander platzieren wollte. Das ist vermutlich
irgendwie möglich, doch war es nach vielen Stunden herausprobieren mir immer noch
nicht gelungen, weshalb ich das wieder verworfen habe.&lt;/p&gt;
&lt;p&gt;Die Wahl fiel letztendlich auf &lt;a href=&#34;https://www.yworks.com/products/yed&#34;&gt;yEd Graph Editor&lt;/a&gt;,
welches leider nicht Open Source ist, aber es ist wenigstens kostenfrei. Da es ein
Java-Tool ist, lässt es sich immerhin ohne Probleme auch unter Linux ausführen.
Damit konnte ich dann nicht nur die Git-Historie schön und mit wenig Aufwand
erstellen, sondern auch die Darstellung von Workflows mit mehreren Clients und
Servern war angenehm möglich.&lt;/p&gt;
&lt;p&gt;Die oben dargestellte Grafik mit den drei Commits aus Gitg, sah mit yEd erzeugt
dann so aus:&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/gitbuch-yed.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die aktuellen Commits auf dem Master-Branch.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/gitbuch-yed.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;h2 id=&#34;statistiken&#34;&gt;Statistiken&lt;/h2&gt;
&lt;p&gt;Durch die Nutzung von Git lassen sich einige Statistiken aus dem Repository
herauslesen. Da ich weder ausschließlich mit reinen Textdateien gearbeitet habe,
noch mit mehreren Personen dran gearbeitet habe, fallen einige mögliche Statistiken
weg. Viele Commits sind vor allem recht groß, vor allem am Anfang, da dort erstmal nur
viel Text geschrieben wurde und zu späteren Zeitpunkten gab es erst viele kleine
Commits, wo jedes Mal Fehler ausgebügelt wurden.&lt;/p&gt;
&lt;p&gt;Den ersten Commit tätigte ich am 12. September 2015 und den letzten finalen Commit
am 15. Juli 2016. Das sind insgesamt 308 Tage, also 10 Monate und 4 Tage. Insgesamt
erzeugte ich 287 Commits.&lt;/p&gt;
&lt;p&gt;Mit dem recht alten, altbackenen Tool &lt;a href=&#34;http://gitstats.sourceforge.net/&#34;&gt;gitstats&lt;/a&gt;
lassen sich weitere Statistiken generieren, etwa die Anzahl der Commits pro Wochentag
pro Stunde:&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/gitbuch-stats1.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Anzahl der Commits pro Stunde&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/gitbuch-stats1.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Oder auch die Anzahl der Commits pro Wochentag, ganz ohne die Aufteilung in die
Stunden:&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/gitbuch-stats2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Anzahl der Commits pro Wochentag&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/gitbuch-stats2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Es gibt noch einige weitere Statistiken und auch verschiedene Tools, die aus Git-Repositories
Statistiken erzeugen. Für mein Buch (und für diesen Blog-Post).&lt;/p&gt;
&lt;p&gt;Die jenigen die  selbst liebäugelt ein Fachbuch zu schreiben, denen empfehle ich
ein Blick auf die Vortragsfolien vom Vortrag &lt;a href=&#34;https://www.deimeke.net/dirk/blog/index.php?/archives/3461-Von-der-Idee-zum-Fach-Buch-....html&#34;&gt;„Von der Idee zum (Fach-)Buch“&lt;/a&gt; von Dirk Deimeke.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Homeserver-Migration auf Ubuntu 16.04</title>
      <link>https://svij.org/blog/2016/04/24/homeserver-migration-auf-ubuntu-1604/</link>
      <pubDate>Sun, 24 Apr 2016 18:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/04/24/homeserver-migration-auf-ubuntu-1604/</guid>
      <description>&lt;p&gt;Vor fast zwei Jahren richtete ich mir meinen ersten &lt;a href=&#34;https://svij.org/blog/2014/07/15/homeserver-setup/&#34;&gt;Homeserver ein&lt;/a&gt;.
Bis letztes Wochenende lief der Rechner noch mit ArchLinux. Generell war der
Betrieb von ArchLinux angenehm: Ich musste fast nichts machen und habe täglich
Updates installiert. Nichtsdestotrotz habe ich jetzt den Homeserver auf Ubuntu 16.04
migriert. Hauptsächlicher Grund war, dass ich durch die Umstellung deutlich mehr an System-Administration
lernen kann, was ich später und auch jetzt  an anderer Stelle gebrauchen kann, als es bei
einem ArchLinux-Server der Fall ist. Die Migration wäre prinzipiell recht einfach
gewesen, wenn ich den grundsätzlichen Aufbau nicht verändert hätte. Die Hardware
hingegen ist gleich geblieben.&lt;/p&gt;
&lt;h2 id=&#34;lxd&#34;&gt;LXD&lt;/h2&gt;
&lt;p&gt;Eines der Gründe wieder auf Ubuntu zu setzen ist der Einsatz von Ubuntu-Tools die
nur eingeschränkt unter ArchLinux laufen oder anderweitig anstrengender sind
zum Laufen zu kriegen. Einige Dienste habe ich deshalb in LXD/LXC-Container verpackt,
was ich deutlich schöner und angenehmer in der Nutzung finde als Docker. Konkret
laufen in einzelnen Containern owncloud, transmission für das Seeden von Ubuntu-ISOs
und gogs.io für das Hosten von Git-Repositorys. Wer sich näher mit LXD beschäftigen will, der
schaut sich am Besten die &lt;a href=&#34;https://www.stgraber.org/2016/03/11/lxd-2-0-blog-post-series-012/&#34;&gt;Blog-Serie&lt;/a&gt;
vom LXD-Entwickler Stéphane Graber an. Für den Einstieg reichen auch schon die
ersten paar Teile. Gegebenenfalls schreibe ich zur Einrichtung und Nutzung von LXD
auch noch einen eigenständigen Artikel.&lt;/p&gt;
&lt;h2 id=&#34;dhcp--und-dns-server&#34;&gt;DHCP- und DNS-Server&lt;/h2&gt;
&lt;p&gt;Der Homeserver dient jetzt auch als DHCP- und DNS-Server im LAN. Mein Hauptproblem
war, dass ich ownCloud innerhalb des LANs nicht über die dynamische DNS erreichen
konnte, Das ist zwar für stationäre Laptops und PCs recht einfach mit einem Eintrag
in &lt;code&gt;/etc/hosts&lt;/code&gt; gelöst, doch geht das nicht auf Android-Geräten. Letztere hatten
nämlich ständig eine unschöne Fehlermeldung angezeigt, dass CalDav, CardDav und
ownCloud Sofort-Uploads nicht zu erreichen sind. Zum Einsatz kommt bei mir &lt;a href=&#34;https://wiki.ubuntuusers.de/Dnsmasq/&#34;&gt;dnsmasq&lt;/a&gt;
was es mit einfachen mitteln erlaubt einen DHCP- und DNS-Server zu betreiben. Im
gleichen Zug habe ich LXD auch an die auf dem Homeserver konfigurierte Bridge
gehangen, damit auch die Container eine IP-Adresse bekommen, damit man einfach
per SSH auf die Container zugreifen kann.&lt;/p&gt;
&lt;h2 id=&#34;filesystem&#34;&gt;Filesystem&lt;/h2&gt;
&lt;p&gt;Das Datengrab mit vormals 2x 2TB-Platten im Software-RAID und einem LVM habe ich
soweit aufgelöst. Dazu gekommen ist eine 120GB-SSD, wo das System und die Container
drauf liegen. Die 2x 2TB-Platten sind jetzt mit einem btrfs RAID-1 bestückt, somit
ohne Software-RAID und ohne LVM. Der kurze Gedanke ZFS einzusetzen war zwar auch
verhanden, habe es allerdings dann doch verworfen. Die Kenntnisse im Umgang mit
btrfs kann ich dann weiterhin gut auch auf anderen Distributionen nutzen.&lt;/p&gt;
&lt;h2 id=&#34;configuration-management-mit-ansible&#34;&gt;Configuration-Management mit Ansible&lt;/h2&gt;
&lt;p&gt;Der wohl letzte Punkt ist die Administration des Servers mit Ansible. Klingt am
Anfang zwar toll und einfach, erfordert aber dann doch recht viel Arbeit, wenn man
es ordentlich machen will. Da der Server doch eher früher als später wieder funktionsfähig
sein sollte, erfolgt die Übernahme der Konfigurationen in Ansible-Playbooks
eher nach und nach. Wiederholende Tasks lassen sich aber besonders einfach und
sinnvoll mit Ansible automatisieren. Besonders das Updaten von mehreren Containern und
den Ubuntu-PCs im Haushalt ist damit deutlich einfacher möglich.&lt;/p&gt;
&lt;h2 id=&#34;fazit&#34;&gt;Fazit&lt;/h2&gt;
&lt;p&gt;Schon jetzt viel Neues gelernt und vieles noch in Planung. Ziel erreicht. ;-)&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>UbuCon Europe Planungen und Call for Contributions</title>
      <link>https://svij.org/blog/2016/04/02/ubucon-europe-planungen-und-call-for-contributions/</link>
      <pubDate>Sat, 02 Apr 2016 18:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2016/04/02/ubucon-europe-planungen-und-call-for-contributions/</guid>
      <description>&lt;p&gt;Es ist schon ein Weilchen her, als ich über die erste &lt;a href=&#34;https://svij.org/blog/2015/06/05/ubucon-europe-2016-in-essen/&#34;&gt;Ankündigung zur UbuCon Europe&lt;/a&gt; in meinem Blog schrieb. Mittlerweile sind die Planungen weiter voran
geschritten. Es wird vom 18. bis zum 20. November im Essener &lt;a href=&#34;http://unperfekthaus.de&#34;&gt;Unperfekthaus&lt;/a&gt;
stattfinden. Wie auch die letzten Jahre begann auch schon die Suche nach &lt;a href=&#34;http://ubucon.org/en/events/ubucon-europe/talks/&#34;&gt;Ideen&lt;/a&gt;
für Vorträge, Workshops und Diskussionsrunden.&lt;/p&gt;
&lt;p&gt;Jeder der eine Idee hat, was er gerne aus dem Ubuntu und Open Source Bereich auf
der UbuCon Europe hören möchte, darf sie gerne per E-Mail an &lt;a href=&#34;mailto:idea@ubucon.eu&#34;&gt;idea@ubucon.eu&lt;/a&gt; schicken.
Die bisherigen Ideen finden sich bereits auf der &lt;a href=&#34;http://ubucon.org/en/events/ubucon-europe/wishlist/&#34;&gt;Wunschliste&lt;/a&gt;.
Wenn du möglicher Vortragender bist, dann kannst du dir ein Thema von der Wunschliste
nehmen, ist natürlich keine Pflicht. Sprachlich planen wir aktuell sowohl deutsche
als auch englische Programmpunkte, sodass es für die deutschen Besuchern ohne gute
Englisch-Kenntnisse ebenfalls interessante Beiträge gibt.&lt;/p&gt;
&lt;p&gt;Mehr Informationen befinden sich auf &lt;a href=&#34;http://ubucon.eu&#34;&gt;UbuCon.eu&lt;/a&gt; oder auf der
&lt;a href=&#34;http://ubucon.de/2016/ubucon-europe-cfc&#34;&gt;deutschen UbuCon Seite&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Besuch bei der OpenRheinRuhr 2015</title>
      <link>https://svij.org/blog/2015/11/09/besuch-bei-der-openrheinruhr-2015/</link>
      <pubDate>Mon, 09 Nov 2015 21:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/11/09/besuch-bei-der-openrheinruhr-2015/</guid>
      <description>&lt;p&gt;Letztes Wochenende fand in Oberhausen die &lt;a href=&#34;http://openrheinruhr.de&#34;&gt;OpenRheinRuhr&lt;/a&gt;
statt. Die OpenRheinRuhr ist für mich als Ruhrgebiet-Mensch meine Heimmesse, da
ich in knapp einer Stunde von zuhause anreisen kann. Seit 2010 war ich auch brav
jedes Mal da und habe mich dieses Mal nicht nur am Ubuntu Stand beteiligt, sondern
habe auch selbst zwei Vorträge gehalten.&lt;/p&gt;
&lt;p&gt;Am Samstag habe ich nur drei Vorträge besucht:&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;http://programm.openrheinruhr.de/2015/events/367.de.html&#34;&gt;foreman - Wie man heutzutage Systeme deployt&lt;/a&gt; war
ein Vortrag von Julius Bloch. Julius hat in seinem Vortrag ein paar Witze
eingestreut und foreman vorgestellt. Für mich gab es letztendlich die Erkenntnis,
das ich das Tool wohl eher weniger zur Zeit brauchen werden.&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;http://programm.openrheinruhr.de/2015/events/372.de.html&#34;&gt;Taskwarrior - Todo-Liste für Geeks&lt;/a&gt; war
ein Vortrag von Oleg Fiksel. Als langjähriger Taskwarrior-Nutzer gab es da für
mich nichts neues zu lernen, was abzusehen war. Es erinnerte mich jedenfalls
stark daran, dass ich mein &lt;a href=&#34;https://github.com/svijee/taskwarrior-androidapp&#34;&gt;altes Projekt&lt;/a&gt;
mal wiederbeleben muss.&lt;/li&gt;
&lt;li&gt;Am meisten habe ich mich auf den Vortrag von Dirk Deimeke über &lt;a href=&#34;http://programm.openrheinruhr.de/2015/events/359.de.html&#34;&gt;Zeit- und Selbstmanagement&lt;/a&gt; gefreut, da ich da gerade noch nach meiner besten Möglichkeit
suche das Privatleben, das Studium, den Job und die Arbeit an den diversen
Open Source Projekten unter einem Hut zu bringen. Jetzt werde ich definitiv
einige der genannten Methoden ausprobieren, um effektiv und möglichst stressfrei
meine Aufgaben in den Griff zu kriegen. Danke Dirk!&lt;/li&gt;
&lt;/ul&gt;
&lt;p&gt;Am Sonntag habe ich keine Vorträge besucht, sondern meine beiden Vorträge gehalten. Um 10
Uhr hielt ich zunächst den &lt;a href=&#34;http://programm.openrheinruhr.de/2015/events/348.de.html&#34;&gt;Ubuntu Phone&lt;/a&gt;
Vortrag, den ich in ähnlicher Fassung auch auf der FrOSCon vor zwei Monaten gehalten
habe. Der Vortragsraum war soweit fast voll. Interessanterweise gab es auf der
FrOSCon viel mehr kritische Nachfragen als es auf der OpenRheinRuhr der Fall war.
Überraschend auch, dass sich fast 10 Leute am Ende gemeldet haben, die sich ein
Ubuntu Phone kaufen wollten, obwohl es explizit keine Marketing-Veranstaltung war ;).
Die Vortragsfolien finden sich &lt;a href=&#34;https://github.com/svijee/ubuntu-phone-froscon/raw/master/output/Ubuntu_Phone_ORR.pdf&#34;&gt;hier&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Ein paar Stunden später hielt ich dann den zweiten Vortrag über &lt;a href=&#34;http://programm.openrheinruhr.de/2015/events/349.de.html&#34;&gt;Snappy Ubuntu Core&lt;/a&gt;. Nicht ganz so voll wie im vorherigen Vortrag, aber besser besucht
als ich gedacht hatte. Wie ich auch am Ubuntu Stand feststellte, ist recht wenig
Wissen bei den Leuten über Snappy Ubuntu Core vorhanden, obwohl da die Zukunft
von Ubuntu liegen wird. Leider spielte das Netzwerk in der Situation nicht ganz
so schön mit, sodass ich die Live-Demo ausfallen lassen musste. Die Vortragsfolien
kann man sich &lt;a href=&#34;https://github.com/svijee/snappy-ubuntu-froscon/raw/master/output/snappy-orr.pdf&#34;&gt;hier anschauen&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Die restliche Zeit verbrachte ich entweder am Ubuntu Stand mit den Kollegen oder
habe mich mit einen der vielen bekannten Gesichter unterhalten. Ob und wo die
Veranstaltung nächstes Jahr stattfindet, ist noch nicht klar. Hierfür sucht
das Orga-Team &lt;a href=&#34;http://blog.openrheinruhr.de/2015/10/11/call-for-location-openrheinruhr-2016/&#34;&gt;nach einem neuen Ort&lt;/a&gt;
im Rhein-Ruhr-Gebiet. Ich drücke jeden Falls die Daumen, dass es auch nächstes
Jahr wieder die Veranstaltung geben wird!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Das war die Ubucon 2015 in Berlin</title>
      <link>https://svij.org/blog/2015/11/01/das-war-die-ubucon-2015-in-berlin/</link>
      <pubDate>Sun, 01 Nov 2015 20:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/11/01/das-war-die-ubucon-2015-in-berlin/</guid>
      <description>&lt;p&gt;Vergangenes Wochenende fand die neunte deutsche Ubucon in Berlin statt. Ich selbst
war dieses Mal erstmals als Hauptorganisator tätig. Nach 2012 waren wir dieses
Mal erneut zu Gast bei der &lt;a href=&#34;http://www.hwtk.de/&#34;&gt;HWTK&lt;/a&gt; mitten in Berlin. Der
Veranstalter war wie jedes Jahr der &lt;a href=&#34;http://verein.ubuntu-de.org&#34;&gt;ubuntu Deutschland e.V.&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;freitag&#34;&gt;Freitag&lt;/h3&gt;
&lt;p&gt;Die Ubucon beginnt traditionell am Freitag. Ich selbst war schon sehr früh in
Berlin und hatte so noch ein wenig Zeit mit zwei Freunden Berlin ein wenig
zu erkunden. Um 14 Uhr ging es dann mit Aufbau los, geholfen haben glücklicherweise
einige freundliche Helfer. Mit dabei waren auch zwei Freifunker, die sich um den
Aufbau der Netzwerkinfrastruktur gekümmert haben. In diesem Sinne: Vielen Dank an
Lynxis, der hier mit seinem Kollegen sehr viel Zeit und Arbeit reingesteckt hat!
Gegen 17.30 ging es dann in Richtung &lt;a href=&#34;http://story-of-berlin.de&#34;&gt;„Story of Berlin“&lt;/a&gt;,
wo wir mit etwas Verspätung die Führung durch den Atomschutzbunker und durch das
Museum bekommen haben. Vor allem der Atomschutzbunker war sehr interessant. Im
Anschluss ging es dann in das Restaurant Route 66, wo nach und nach noch mehr Leute dazu
stießen, sodass wir dort knapp 40 Leute waren.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubucon2015_route66.webp&#34; data-lightbox=&#34;image&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/ubucon2015_route66.webp&#34; width=&#34;400&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;h3 id=&#34;samstag&#34;&gt;Samstag&lt;/h3&gt;
&lt;p&gt;Samstag morgens um 9 Uhr eröffneten wir die Anmeldung. Etwa zu der Zeit kamen
auch das Catering in Form von Brötchen, Canapés, Sandwiches und Salate an.
Lustigerweise waren die Leute vom Catering-Service ebenfalls zufriedene Ubuntu-Nutzer.&lt;/p&gt;
&lt;p&gt;Als Hauptorganisator eröffnete ich kurz vor 10 Uhr kurz und knackig die Ubucon.
Das Programm enthielt dieses Mal ein wenig mehr Ubuntu-Themen, aber auch andere
Themen wie ownCloud, die Sicherheit der eigenen Daten oder Grafik-Design mit Open
Source Software wurden abgedeckt. Ich selbst begab mich erst nach der Mittagspause
um 14 Uhr zu meinen ersten Vorträgen. Zusammen mit Simon ging es zunächst zu
der Siegerehrung des UbuContests, welches wir gemeinsam mit Daniel Holbach und David Planella organisiert hatten. Schön
war, dass sowohl Riccardo Padovani aus Italien als auch Michał Prędotka aus Schottland
angereist sind. Zudem hat es auch der junge Jorik van Nielen aus den Niederlanden
nach Berlin geschafft. Simon hatte für die Siegerehrung extra ein paar Videos
mit Blender erstellt, die durchaus sehenswert sind: &lt;a href=&#34;https://www.youtube.com/watch?v=9xexCCAWbDs&#34;&gt;Intro Video&lt;/a&gt;,
&lt;a href=&#34;https://www.youtube.com/watch?v=jj4yAImbJ8w&#34;&gt;das inoffizielle Ubucon-Video&lt;/a&gt;, &lt;a href=&#34;https://www.youtube.com/watch?v=gVZ04kNqpE8&#34;&gt;Falldown&lt;/a&gt;, sowie &lt;a href=&#34;https://www.youtube.com/watch?v=LZTPaR2MO-8&#34;&gt;Monster Wars&lt;/a&gt;.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubucon2015_david_planella.webp&#34; data-lightbox=&#34;image&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/ubucon2015_david_planella.webp&#34; width=&#34;400&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Ubuntu Community-Team Manager David Planella gab im Anschluss einen Vortrag über
„The Ubuntu phone and the road to convergence“, der sehr interessant war und auch
für mich einige Neuigkeiten enthielt. Leider wurde dieser Vortrag nicht vollständig
aufgezeichnet. Nach diesem Vortrag war ich auch wieder mit einem Vortrag dran, dieses
Mal zusammen mit den beiden Canonical-Mitarbeitern Daniel Holbach und Oliver Grawert
über Snappy Ubuntu Core. Abschlossen wurde der Samstag mit dem (fast) alljährlichen
Linux-Quiz, der dieses Mal vor allem durch die Instabilität des Programmes herausragte. ;)&lt;/p&gt;
&lt;p&gt;Relativ kurzfristig mussten wir kurz vor Beginn der Ubucon noch das Social-Event
verschieben, so dass es im Cum Laude Restaurant stattfand.&lt;/p&gt;
&lt;h3 id=&#34;sonntag&#34;&gt;Sonntag&lt;/h3&gt;
&lt;p&gt;Die Nacht zum Sonntag war durch den bedingten Winterzeitwechsel zum Glück eine
Stunde länger. Am meisten motiviert waren noch vor 9 Uhr trotzdem die Leute des
Catering-Services beim Anliefern des Essens ;). Am Sonntag ist in der Regel
weniger los als am Samstag, was auch durch den kürzeren Programm bedingt ist.
Ich besuchte zunächst den systemd-Dienste Vortrag von Stefan Betz, anschließend
sah ich mir den „Was ist Cloud?“ Vortrag von Kristian Köhntopp an, den ich schon
auf der FrOSCon besucht hatte. Nach der Mittagspause gab es von Simon Raffeiner
den „Linux und Supercomputing“ Vortrag und anschließend gab es mit mir eine kleine
Diskussionsrunde zur &lt;a href=&#34;http://ubucon.eu&#34;&gt;UbuCon Europe&lt;/a&gt;, die nächstes Jahr in Essen stattfinden wird.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubucon2015_owncloud-vortrag.webp&#34; data-lightbox=&#34;image&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/ubucon2015_owncloud-vortrag.webp&#34; width=&#34;400&#34; style=&#34;margin:10px;&#34;&gt;
&lt;/a&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Für mich war es die vierte Ubucon insgesamt, die dritte als Teil des Organistationsteam
und die erste als Hauptorganisator. Es ging insgesamt deutlich stressfreier von
statten, als ich mir zuvor erwartet hatte. Dies hängt aber auch mit dem Rest
des Organisationsteams zusammen, die bei vielen Sachen geholfen und mitgeholfen haben. Deshalb geht
hier mein Dank an Torsten Franz und Dominik Wagenführ für die Organisation vor dem
Event und an Peter und Adrian für die Unterstützung von Seiten der HWTK und vor
Ort in Berlin. Großen Dank gilt auch Lynxis für die Netzwerk-Infrastruktur, die größtenteils
stabil und deutlich besser als die Jahre zuvor funktioniert hatte. Zusätzlich möchte
ich mich auch bei Jasmin und Jens für die Hilfe an der Anmeldung und beim Aufbau
bedanken. Natürlich gebührt der Dank weiterhin allen anderen Leuten, die in irgendeinerweise
mit geholfen haben, darunter auch die Referenten.&lt;/p&gt;
&lt;p&gt;Insgesamt kamen fast 120 Personen zur Ubucon. Durch die verkürzte Planung, die im
Mai begann, ist das durchaus gut, so bewegten wir uns in dem selben Rahmen wie in den
Jahren davor.&lt;/p&gt;
&lt;p&gt;Nächstes Jahr findet die zehnte Ubucon in Deutschland statt. Dieses Mal planen wir die ersten
europäische Ubucon die in Essen stattfinden wird. Genauere Details, wie das genaue
Datum, werden noch in Zukunft bekannt gegeben. Dazu existiert bereits die provisorische
&lt;a href=&#34;http://ubucon.eu/&#34;&gt;ubucon.eu&lt;/a&gt;-Webseite, sowie eine &lt;a href=&#34;https://launchpad.net/~ubuconeu&#34;&gt;Launchpad-Gruppe&lt;/a&gt;
in der die Planung stattfinden wird. Beim Ubuntu Online Summit gibt es ebenfalls
eine &lt;a href=&#34;http://summit.ubuntu.com/uos-1511/meeting/22619/ubucon-europe-planning/&#34;&gt;Session&lt;/a&gt; zur Planung.
Wer mithelfen will, der darf gerne dazustoßen. Die Sprache ist allerdings dann
vollständig auf Englisch.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Professionell entwickeln mit JavaScript</title>
      <link>https://svij.org/blog/2015/10/11/rezension-professionell-entwickeln-mit-javascript/</link>
      <pubDate>Sun, 11 Oct 2015 19:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/10/11/rezension-professionell-entwickeln-mit-javascript/</guid>
      <description>&lt;p&gt;Das Buch „Professionell entwickeln mit JavaScript“ des Autors Philip Ackermann
behandelt grundsätzlich das Entwickeln von Anwendungen mit der Programmiersprache JavaScript.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Das Buch unterteilt sich in acht Kapiteln, die insgesamt 450 Seiten lang sind. Zu Beginn wird eine Einführung in JavaScript gegeben, in dem die gängigen Begriffe erläutert, die vorhandenen Laufzeitumgebungen genannt sowie ein Überblick über eine Auswahl von existierenden Entwicklungsumgebungen und Debugging-Tools geliefert werden. Das Kapitel schließt mit der ersten Einführung in die Sprache selbst ab.
Das zweite Kapitel befasst sich mit den Funktionen und den funktionalen Aspekten von JavaScript. Es wird unter anderem eine Einführung in die funktionale Programmierung gegeben und die Unterschiede zur imperativen Programmierung aufgezeigt. Das dritte Kapitel umfasst das Thema der objektorientierten Programmierung. Dort wird erläutert, wie man objektorientiert in JavaScript programmiert, also wie man Klassen programmiert und wie man mit Prototypen, Vererbungen und Datenkapselungen arbeitet. Weiterhin wird die Emulation von diversen weiteren Prinzipien der objekt-orientierten Programmierung erklärt.&lt;/p&gt;
&lt;p&gt;Im vierten Kapitel geht es um den neuen ECMAScript Standard in Version 6, der erst kürzlich, im Juni 2015, veröffentlicht wurde. Das Kapitel umfasst alle Neuerungen und Änderungen und zeigt, wie man sie im Alltag verwenden kann. Im darauffolgenden fünften Kapitel dreht es sich um den Entwicklungsprozess. Es werden sehr viele JavaScript-Bibliotheken und Node.js-Pakete genannt, die für den Entwicklungsprozess hilfreich sind, um etwa die Code-Qualität zu verbessern oder den Code für das Deployment zu minifizieren.
Das sechste Kapitel dreht sich rund um das Test-Drive-Development von JavaScript-Anwendungen, es begrenzt sich nicht nur auf das Testen von JavaScript-Anwendungen auf Webseiten sondern es wird auch erläutert, wie man mit diversen Test-Frameworks Node.js-Anwendungen testet. Im anschließenden vorletzten Kapitel dreht es sich um die Entwurfsmuster der „Gang of Four“. So werden viele verschiedene Entwurfsmuster aus der Softwaretechnik genannt, erläutert und gezeigt, wie man diese in JavaScript umsetzt. Zum Schluss folgen im letzten Kapitel die verschiedenen Architekturmuster von modernen JavaScript-Frameworks, wie sie in AngularJS, Backbone.js und Co. eingesetzt werden.&lt;/p&gt;
&lt;h3 id=&#34;wie-liest-es-sich&#34;&gt;Wie liest es sich?&lt;/h3&gt;
&lt;p&gt;Der Autor beschreibt in dem Buch sehr viele Aspekte von JavaScript, die teilweise kompliziert und umfangreich sind. Einige Passagen muss man gegebenenfalls mehrfach lesen um es vollständig zu verstehen. Die Erklärungung sind in der Regel kurz und knackig, sodass nicht sehr viel um den heißen Brei herumgeredet wird.
Der Autor bringt immer wieder Erfahrungen und Tipps ein, die für das reale Arbeiten hilfreich sind, etwa wann man diverse Dinge tun sollte und wann man es vermeiden sollte.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Das Buch richtet sich primär an Leute, die schon Erfahrungen mit einer Programmiersprache haben und sich JavaScript aneigenen wollen. Diesen Umstand merkt man auch im Buch, da das gängige Programmierverständnis vorausgesetzt wird. Nichtsdestotrotz ist das Buch auch für Programmierer geeignet, die bisher nur wenig Programmiererfahrung besitzen.&lt;/p&gt;
&lt;p&gt;Der Titel des Buches impliziert, dass man durch dieses Buch mit JavaScript professionell programmieren lernen kann. Dem wird das Buch auch vollkommen gerecht, da eine große Breite an Themen, die sich rund um das Thema JavaScript drehen, behandelt werden. Positiv ist zudem hervorzuheben, dass nicht im Detail auf jede mögliche Syntax eingegangen wird, also wie man etwa Schleifen programmiert oder if-Abfragen tätigt. Dadurch ist viel Platz für die wirklich notwendigen Dinge vorhanden, die sonst zu kurz kämen. Ebenfalls positiv hervorzuheben ist, dass sich der Autor nicht auf spezielle JavaScript-Bibliotheken festlegt, von denen es ja mittlerweile sehr viele gibt. So können auch Leser dem Buch was abgewinnen, die JavaScript nicht im Browser nutzen.&lt;/p&gt;
&lt;p&gt;Weiterhin werden häufig bei der Nennung von JavaScript-Bibliotheken Alternativen aufgezeigt und Tipps gegeben, welche Vor- und Nachteile die jeweilige Bibliothek hat, etwa ob man grunt oder gulp einsetzen sollte. Viel von den JavaScript-Funktionen selbst lernt man wiederum nicht, also z. B. wie man mit Datums-Objekten arbeitet. Dieser Fakt schadet aber dem Buch keineswegs, da man solche Dinge sowieso schneller im Internet nachschlägt. Für knapp 35€ erhält man ein gutes Buch, um einen vollständigen Einblick in das Arbeiten mit JavaScript zu gewinnen.&lt;/p&gt;
&lt;h3 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; &lt;a href=&#34;https://www.rheinwerk-verlag.de/professionell-entwickeln-mit-javascript_3365/&#34;&gt;Professionell entwickeln mit JavaScript&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt;  Philip Ackermann&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt;  Rheinwerk&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt;  450 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt;  978-3-8362-2379-9&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 34,90 Euro (broschiert), 29,90 Euro (E-Book)&lt;/p&gt;
&lt;p&gt;Da es schade wäre, wenn das Buch bei mir im Regal verstaubt, wird es verlost. Dies
ist „drüben“ bei &lt;a href=&#34;http://www.freiesmagazin.de/20151011-oktoberausgabe-erschienen&#34;&gt;freiesMagazin&lt;/a&gt;
in den Kommentaren möglich.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>FrOSCon</title>
      <link>https://svij.org/blog/2015/08/25/froscon/</link>
      <pubDate>Tue, 25 Aug 2015 20:20:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/08/25/froscon/</guid>
      <description>&lt;p&gt;Vergangenes Wochenende, am 22. und 23. August, fand die &lt;a href=&#34;https://froscon.de&#34;&gt;FrOSCon&lt;/a&gt;
in St. Augustin statt und ich war dieses Jahr zum ersten Mal da. Kurz zusammengefasst:
Die Veranstaltung war super! Es gab sehr viele interessante Vorträge, viele davon
auch leider gleichzeitig, was sich nicht vermeiden lässt. Alle Vorträge wurden
dankenswerterweise &lt;a href=&#34;https://media.ccc.de/browse/conferences/froscon/2015/index.html&#34;&gt;aufgezeichnet&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Ich selbst war zunächst am Samstagmorgen in den beiden Vorträgen, die ich gehalten
habe. Zunächst über Snappy Ubuntu Core und anschließend über Ubuntu Phone. Beide
Vorträge waren gut besucht, im Ubuntu Phone Vortrag waren aber letztendlich noch
ein wenig mehr Leute da als beim Snappy Vortrag. Der Ubuntu Phone Vortrag lässt sich
&lt;a href=&#34;https://media.ccc.de/browse/conferences/froscon/2015/froscon2015-1503-ubuntu_phone.html&#34;&gt;hier&lt;/a&gt;
anschauen, während man den Snappy Vortrag &lt;a href=&#34;https://media.ccc.de/browse/conferences/froscon/2015/froscon2015-1523-snappy_ubuntu_core.html#video&#34;&gt;hier&lt;/a&gt; findet.&lt;/p&gt;
&lt;p&gt;Am Samstag war ich sonst in keinen anderen Vorträgen, am Abend gab es dann das Social
Event, wo es kostenlos Essen vom Grill gab. Auch der Eintritt war für jeden Besucher
in diesem Jahr frei!&lt;/p&gt;
&lt;p&gt;Sonntag ging es dann los mit &lt;a href=&#34;https://media.ccc.de/browse/conferences/froscon/2015/froscon2015-1645-access_without_empowerment.html&#34;&gt;„Access Without Empowerment“&lt;/a&gt; von Benjamin Mako Hill. Später war ich in dem
äußerst interessanten und auch unterhaltsamen Vortrag &lt;a href=&#34;https://media.ccc.de/browse/conferences/froscon/2015/froscon2015-1693-was_ist_cloud.html&#34;&gt;„Was ist Cloud?“&lt;/a&gt; von Kristian Köhntopp, der sehr sehenswert ist.
Der Talk über &lt;a href=&#34;https://media.ccc.de/browse/conferences/froscon/2015/froscon2015-1512-ansible_basics.html#video&#34;&gt;„Ansible“&lt;/a&gt; hat einen kurzen und guten Einblick in die Nutzung von Ansible als Deployment-Tool gegeben.
Die übrige Zeit stand ich vor oder hinter dem Ubuntu-Stand, hauptsächlich wollten
wo ich mit vielen Besuchern vor allem über Ubuntu Phone gesprochen habe. Auch
gab es ein kleines Taskwarrior-Meetup mit Lynoure Braakman, Wim Schürmann, Dirk Deimeke
und mir; ein Foto davon gibt es bei &lt;a href=&#34;http://www.deimeke.net/dirk/blog/index.php?/archives/3607-Mini-Taskwarrior-Meetup-....html&#34;&gt;Dirk im Blog&lt;/a&gt;.
Mit Niklas Wenzel und Christian Dywan hab ich zufällig auch noch zwei weitere Personen
aus der Ubuntu-Community getroffen, die ich bisher noch nicht getroffen habe.&lt;/p&gt;
&lt;p&gt;Nächstes Jahr geht es jedenfalls für mich definitiv wieder dorthin. Bis dahin steht
dieses Jahr noch die &lt;a href=&#34;http://ubucon.de&#34;&gt;Ubucon&lt;/a&gt; und die &lt;a href=&#34;http://openrheinruhr.de&#34;&gt;OpenRheinRuhr&lt;/a&gt; an.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>UbuContest startet!</title>
      <link>https://svij.org/blog/2015/07/18/ubucontest-startet/</link>
      <pubDate>Sat, 18 Jul 2015 12:25:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/07/18/ubucontest-startet/</guid>
      <description>&lt;p&gt;Gestern haben wir auf der Ubucon-Webseite die große Ankündigung gemacht: &lt;a href=&#34;http://ubucon.de/2015/announcement-ubucontest-de&#34;&gt;Der Start des UbuContests&lt;/a&gt;. Der Wettbewerb läuft in Zusammenarbeit mit Canonical, welche
(fast) alle Gewinne zur Verfügung stellt, darunter das ein oder andere Ubuntu Phone
von bq und Meizu, Produkte aus dem Ubuntu Shop und eine Reiseunterstützung zur Ubucon nach
Berlin.&lt;/p&gt;
&lt;p&gt;Insgesamt gibt es fünf verschiedene Kategorien, die sich nicht nur an Entwickler
richtet, sondern auch an Leute, die etwa als fleißiger Tester, Übersetzungen oder
auch als Designer aktiv sind. Auch die Community hat die Möglichkeit seine eigenen
Favoriten zu nominieren.&lt;/p&gt;
&lt;p&gt;Der Wettbewerb endet am 18. September. Danach wird die Jury aktiv, die ebenfalls (mit einer Ausnahme)
aus Mitgliedern der Community bestehen. Das sind konkret Carla Sella aus Italien,
Laura Cowen aus dem Ubuntu UK Podcast, Simos Xenitellis aus Griechenland, Michael
Zanetti von Canonical und meiner Wenigkeit.&lt;/p&gt;
&lt;p&gt;Ich bin gespannt, welche neuen Apps oder Scopes eingereicht werden und hoffe auf
eine rege Beteiligung! :)&lt;/p&gt;
&lt;p&gt;Nähere Informationen finden sich &lt;a href=&#34;http://ubucon.de/2015/contest&#34;&gt;hier&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ubuntu auf der FrOSCon</title>
      <link>https://svij.org/blog/2015/07/18/ubuntu-auf-der-froscon/</link>
      <pubDate>Sat, 18 Jul 2015 12:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/07/18/ubuntu-auf-der-froscon/</guid>
      <description>&lt;p&gt;Am 22. und 23. August findet in St. Augustin bei Bonn die &lt;a href=&#34;https://www.froscon.de&#34;&gt;FrOSCon&lt;/a&gt;
statt. Für mich wird es der erste Besuch bei dieser Konferenz sein. Das Programm
wurde &lt;a href=&#34;http://programm.froscon.de/2015/&#34;&gt;kürzlich&lt;/a&gt; veröffentlicht.&lt;/p&gt;
&lt;p&gt;Mit dabei ist auch ein Vortrag von mir: &lt;a href=&#34;http://programm.froscon.de/2015/events/1523.html&#34;&gt;„Snappy Ubuntu Core“&lt;/a&gt;.
Dieser findet direkt zum Start am Samstag um 10 Uhr statt. Im Anschluss folgt
ein Ubuntu Phone Vortrag, der leider nicht von mir ist.
Unabhängig davon sind einige interessante Vorträge dabei, die ich mir anschauen möchte.&lt;/p&gt;
&lt;p&gt;Mich findet man erneut am Ubuntu Stand, zusammen mit &lt;a href=&#34;https://ubuntuusers.de/user/Hefeweiz3n/&#34;&gt;hefeweiz3n&lt;/a&gt;
(also der Person hefeweiz3n, nicht mit Bier!). Voraussichtlich werden auch meine
beiden Ubuntu Phones (bq Aquaris E4.5 und das Meizu MX4) verfügbar sein, für die
Leute, die es ansehen und ausprobieren möchten.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Git - Verteilte Versionsverwaltung für Code und Dokumente</title>
      <link>https://svij.org/blog/2015/07/05/rezension-git-verteilte-versionsverwaltung-f%C3%BCr-code-und-dokumente/</link>
      <pubDate>Sun, 05 Jul 2015 15:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/07/05/rezension-git-verteilte-versionsverwaltung-f%C3%BCr-code-und-dokumente/</guid>
      <description>&lt;p&gt;Das Buch „Git - Verteilte Versionsverwaltung für Code und Dokumente“ von den
Autoren Valentin Haenel und Julius Plenz gibt einen ausfürhlichen Einblick in die
Nutzung von Git. Das Buch erschien im Open Source Press Verlag.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Das Buch umfasst 336 Seiten auf insgesamt neun Kapiteln sowie einen Anhang. Diese
werden zudem in drei Kategorien „Grundlagen“, „Fortgeschrittene Szenarien“
und dem Anhang aufgeteilt.&lt;/p&gt;
&lt;p&gt;Die Grundlagen unterteilen sich in sechs Kapiteln. Zu Beginn zunächst die
Einführung, in der die ersten Schritte mit Git erläutert werden. Dies umfassst
im wesentlichen die notwendigen Begriffe und deren Erläuterungen, um mit Git
arbeiten zu können. Weiterhin wird das Anlegen eines ersten Repositorys mit den ersten
Commits thematisiert. Außerdem wird die grundsätzlichen Git Konfigurationen genannt und erläutert.&lt;/p&gt;
&lt;p&gt;Im zweiten Kapitel folgen die gängigen Git-Kommandos die für das tägliche Arbeiten
mit Git gebraucht werden, sowie die Erläuterungen des Objektmodells. Im anschließenden
dritten Kapitel dreht es sich hauptsächlich um das Arbeiten mit Branches und Tags.
So wird erklärt, wie man Branches erstellt und wie man diese wieder zusammenführt.&lt;/p&gt;
&lt;p&gt;Das vierte Kapitel behandelt fortgeschrittene Konzepte, wie etwa das Rebasen, inklusiver
Tipps wie und wann man Rebasen sollte und wann nicht. Weiterhin wird vermittelt,
wie man Dateien ignoriert und was die Befehle &amp;ldquo;git stash&amp;rdquo; und &amp;ldquo;git blame&amp;rdquo; machen.&lt;/p&gt;
&lt;p&gt;Erst im fünften Kapitel geht es um die verteilten Git-Repositorys, also wie man
Remote-Repositorys hinzufügt, die Daten herunterlädt und deren Branches in die
eigenen Entwicklungsbranches mergt und wie man Commits wieder hochlädt. Außerdem
wird noch thematisiert, wie man Patches per E-Mail versenden kann und wie man Submodules
einbindet und verwaltet. Die Grundlagen schließen mit einem kurzem Kapitel zu
Git-Workflows ab.&lt;/p&gt;
&lt;p&gt;Nach den Grundlagen-Kapitel folgen die fortgeschrittenen Szenarien, worin es
zunächst in Kapitel 7 um das Hosten von Git auf dem Server geht. Darin werden
verschiedene Optionen mit ihren Vor- und Nachteilen genannt, darunter etwa der Einsatz
von Gitolite. Das achte Kapitel umfasst die Automatisierungsfunktionen von Git, also
Attribute, Hooks und das Schreiben von eigenen Git-Kommandos. Das letzte Kapitel
erläutert im wesentlichen das Zusammenspiel von Git mit Subversion, mittels des
&amp;ldquo;git-svn&amp;rdquo; Tools.&lt;/p&gt;
&lt;p&gt;Im Anhang befinden sich weiterführende Texte, darunter die Installation von Git,
die Struktur eines Repositorys, die Shell-Integration sowie einige Seiten über GitHub.&lt;/p&gt;
&lt;h3 id=&#34;wie-liest-es-sich&#34;&gt;Wie liest es sich?&lt;/h3&gt;
&lt;p&gt;Das Buch bietet einen tiefen und detailreichen Einstieg in Git. Die Erläuterungen
sind in der Regel klar und deutlich, sodass man die Vorgehensweise mit Git
gut verstehen kann. Das Buch richtet sich nicht auf Um- oder Einsteiger aus, sodass
wenige Vergleiche zu anderen Versionskontrollsystemen gezogen werden. Der
Leser erfährt dadurch auch keine Unterschiede zu anderen Systemen und worin Git besser
oder schlechter ist.&lt;/p&gt;
&lt;p&gt;Die Autoren legen großen Wert auf das Verständnis des Git-Objektmodells, so referenzieren
sehr viele Erläuterungen auf das Kapitel über das Git-Objektmodell. Der Leser
erfährt dadurch nicht nur, wie man mit Git arbeitet, sondern auch, wie Git selbst
arbeitet was für das tägliche Arbeiten mit Git durchaus sinnvoll sein kann.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Während die Erläuterungen in dem Buch sehr detailreich sind, wird hin und wieder
nicht klar, warum ein Funktion sinnvoll ist und wie oft man es im täglichen
Nutzen von Git braucht. Bereits am Anfang des Buches werden sehr viele
Details erläutert. Um die Sinnhaftigkeit von Funktionen besser darzustellen, bietet
es sich meiner Meinung nach besser an, mehr auf Praxis-Beispiele zu beziehen, die
nicht nur bloß genannt werden, sondern auch beispielhaft vorgeführt werden.&lt;/p&gt;
&lt;p&gt;Der Leser muss bereits am Anfang sehr viel lesen, um mit Git sinnvoll
starten zu können. Dadurch, dass häufig keine Praxisbeispiele am Anfang genannt
werden, muss der Leser selbst herumexperimentieren um sich mit Git vertraut zu machen.
Durch die starke Bindung an das Git-Objektmodell sind viele Begriffe Englisch und
technische Bezeichner. Die Erklärungen werden dadurch manchmal nicht ganz so einfach
verständlich, was vor allem für Einsteiger problematisch sein kann. Schade ist auch,
dass nur wenig auf Workflows eingegangen wird. Das vorhandene Kapitel hierzu ist
nur wenige Seiten lang.&lt;/p&gt;
&lt;p&gt;Nichtsdestotrotz bietet das Buch viele Details, die selbst ein erfahrener Git-Nutzer
nicht kennt. Es werden häufig auch Tipps und Tricks eingeworfen die für das tägliche
Arbeiten mit Git hilfreich sind. Das sind in der Regel Aliase die gesetzt werden
können, um lange Befehle mit vielen Parametern abzukürzen.&lt;/p&gt;
&lt;h3 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; &lt;a href=&#34;http://www.opensourcepress.de/de/produkte/Git/33227/978-3-95539-119-5&#34;&gt;Git - Verteilte Versionsverwaltung für Code und Dokumente&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Valentin Haenel und Julius Plenz&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt; Open Source Press&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt; 336 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt; 978-3-95539-120-1&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 29,90€ (broschiert), 24,99 (E-Book)&lt;/p&gt;
&lt;p&gt;Da es schade wäre, wenn das Buch bei mir im Regal verstaubt, wird es verlost. Dies
ist „drüben“ bei &lt;a href=&#34;http://www.freiesmagazin.de/20150705-juliausgabe-erschienen&#34;&gt;freiesMagazin&lt;/a&gt;
in den Kommentaren möglich.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Video Hands on bq Aquaris E5 Ubuntu Edition</title>
      <link>https://svij.org/blog/2015/06/25/video-hands-on-bq-aquaris-e5-ubuntu-edition/</link>
      <pubDate>Thu, 25 Jun 2015 20:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/06/25/video-hands-on-bq-aquaris-e5-ubuntu-edition/</guid>
      <description>&lt;p&gt;Gestern habe ich mein insgesamt drittes Ubuntu Phone bekommen. Das Marketing-Team
von bq war so nett und hat mir für zwei Wochen das &lt;em&gt;bq Aquaris E5 Ubuntu Edition&lt;/em&gt;
überlassen, was ich testen kann.&lt;/p&gt;
&lt;p&gt;Wie auch beim &lt;a href=&#34;https://svij.org/blog/2015/06/21/video-hands-on-meizu-mx4-ubuntu-edition/&#34;&gt;Meizu MX4&lt;/a&gt;
habe ich ein kurzes Video aufgenommen, wo ich im wesentlichen die Unterschiede zum
Schwester-Modell dem Aquaris E4.5 aufzeige. Ein ausführliches Review folgt natürlich
auch noch.&lt;/p&gt;
&lt;p&gt;Das Video habe ich auf YouTube hochgeladen und lässt sich &lt;a href=&#34;https://www.youtube.com/watch?v=tcyf1Fe_jGM&#34;&gt;hier ansehen&lt;/a&gt;&lt;/p&gt;
&lt;iframe width=&#34;420&#34; height=&#34;315&#34; src=&#34;https://www.youtube.com/embed/tcyf1Fe_jGM&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
</description>
    </item>
    
    <item>
      <title>Video Hands on Meizu MX4 Ubuntu Edition</title>
      <link>https://svij.org/blog/2015/06/21/video-hands-on-meizu-mx4-ubuntu-edition/</link>
      <pubDate>Sun, 21 Jun 2015 22:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/06/21/video-hands-on-meizu-mx4-ubuntu-edition/</guid>
      <description>&lt;p&gt;Ich bin nun seit wenigen Tagen im Besitz des „Meizu MX4 Ubuntu Edition“, also
nach dem „bq Aquaris E4.5“ das zweite Ubuntu Phone, welches allerdings zum jetzigen
Zeitpunkt noch nicht käuflich erwerbbar ist.&lt;/p&gt;
&lt;p&gt;Heute habe ich ein kurzes Video aufgenommen, in dem ich ein wenig auf die Hardware
und die Besonderheiten des Telefons eingehe. Obwohl ich eigentlich nicht dachte,
dass das Video lang wird, ist es mit fast 7 Minuten doch länger als ich ursprünglich
geplant hatte.&lt;/p&gt;
&lt;p&gt;Das Video habe ich auf YouTube hochgeladen und lässt sich &lt;a href=&#34;https://www.youtube.com/watch?v=CRCGdWT952Q&#34;&gt;hier ansehen&lt;/a&gt;.&lt;/p&gt;
&lt;iframe width=&#34;560&#34; height=&#34;315&#34; src=&#34;https://www.youtube.com/embed/CRCGdWT952Q&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
&lt;p&gt;Ein ausführlicher Test-Bericht folgt im Laufe der nächsten Wochen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ubucon Europe 2016 in Essen</title>
      <link>https://svij.org/blog/2015/06/05/ubucon-europe-2016-in-essen/</link>
      <pubDate>Fri, 05 Jun 2015 22:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/06/05/ubucon-europe-2016-in-essen/</guid>
      <description>&lt;p&gt;Vor einigen Tagen haben wir die &lt;a href=&#34;https://svij.org/blog/2015/05/24/ubucon-2015-in-berlin/&#34;&gt;Ubucon 2015 angekündigt&lt;/a&gt;,
welche dieses Jahr in Berlin stattfinden wird. Durch die Planungen für dieses Jahr
haben wir glücklicherweise auch schon einen Ort für das nächste Jahr so gut wie sicher.&lt;/p&gt;
&lt;p&gt;Nächstes Jahr würde die zehnte Ubucon in Deutschland stattfinden und wir dachten,
dass es doch eine gute Gelegenheit wäre, die Ubucon deutlich zu erweitern. Bereits vor
einigen Monaten hatte &lt;a href=&#34;https://plus.google.com/u/0/+MarcosCostales/posts/jLzUVbFmHuv&#34;&gt;Costales&lt;/a&gt;
auf Google+ an diverse „Ubuntu Phone Insider“ gefragt, ob eine europäische Ubucon
nicht toll wäre, was von allen bejaht wurde. Bislang passierte da aber nach knapp
drei Monaten nicht viel… bis jetzt! :)&lt;/p&gt;
&lt;h3 id=&#34;ubucon-europe&#34;&gt;Ubucon Europe!&lt;/h3&gt;
&lt;p&gt;Wir - das Organisationsteam der deutschen Ubucon - erweitern damit die Ubucon
nächstes Jahr zur &lt;em&gt;Ubucon Europe 2016&lt;/em&gt;! Wir sind aktuell noch in einer sehr
frühen Phase der Planung und wir brauchen daher auch Feedback. Die Ubucon Europe
wird in Essen stattfinden, an einem Wochenende im September oder Oktober. Der genaue
Ort ist noch nicht fix, wir haben allerdings noch zwei Optionen innerhalb von Essen
offen, wo die Ubucon Europe unterkommen kann. Dadurch, dass Essen im Ruhrgebiet ist,
lässt es sich gut über den Zug-Fernverkehr erreichen und auch der Düsseldorfer Flughafen
ist für internationale Gäste nicht fern.&lt;/p&gt;
&lt;h3 id=&#34;feedback&#34;&gt;Feedback!&lt;/h3&gt;
&lt;p&gt;Wir haben erst kürzlich die Domain &lt;a href=&#34;http://ubucon.eu&#34;&gt;ubucon.eu&lt;/a&gt; gesichert, wo
zukünftige Ankündigungen erfolgen werden. Zu Beginn brauchen wir allerdings Feedback
für die weiteren Planungen. In den letzten Jahren hatten wir meistens um die 150
Teilnehmer bei einer deutschen Ubucon, wie die Teilnehmerzahl bei einer Ubucon
Europe aussehen würde, können wir zur Zeit nicht erahnen.&lt;/p&gt;
&lt;p&gt;Dieser Blogpost läuft auch in Englisch über &lt;a href=&#34;http://planet.ubuntu.com&#34;&gt;planet.ubuntu.com&lt;/a&gt;,
um die Resonanz zu erfragen. Auch hier stelle ich an die deutsche Community die
Frage, wer zu einer europäischen Ubucon nach Essen kommen würde und ob Interesse
daran besteht, einen Vortrag oder Workshop in englischer Sprache zu halten. Ob oder
in welcher Form wir deutsche Vorträge zulassen, ist noch nicht diskutiert worden.
Nebenbei suchen wir natürlich weiterhin Leute, die bei der Ubucon mithelfen wollen.
Dies betrifft nicht nur die Ubucon Europe im nächsten Jahr sondern
auch die diesjährige Ubucon in Berlin!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ubucon 2015 in Berlin</title>
      <link>https://svij.org/blog/2015/05/24/ubucon-2015-in-berlin/</link>
      <pubDate>Sun, 24 May 2015 23:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/05/24/ubucon-2015-in-berlin/</guid>
      <description>&lt;p&gt;Vor wenigen Stunden haben wir die mittlerweile neunte deutsche Ubucon
&lt;a href=&#34;http://ubucon.de/2015/community-in-touch&#34;&gt;angekündigt&lt;/a&gt;. Ich selbst bin seit
der Ubucon 2013 in Heidelberg im Organisationsteam. Dieses Jahr bin ich erstmals
Hauptorganisator. Im Idealfall verteile ich also erfolgreich die Aufgaben an die
anderen Leute im Organisationsteam, in der Realität sieht das ein wenig anders aus. ;-)&lt;/p&gt;
&lt;p&gt;Die Ubucon findet dieses Jahr in Berlin an der &lt;a href=&#34;http://www.hwtk.de/&#34;&gt;HWTK&lt;/a&gt; vom
23. bis 25. Oktober 2015 statt. Am gleichen Ort wurde bereits die Ubucon im
Jahr 2012 veranstaltet. Auch der &lt;a href=&#34;http://ubucon.de/2015/cfp&#34;&gt;„Call for Papers“&lt;/a&gt;
wurde zeitgleich gestartet.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git für Einsteiger - Teil 4 (GitHub-Edition)</title>
      <link>https://svij.org/blog/2015/05/10/git-f%C3%BCr-einsteiger-teil-4-github-edition/</link>
      <pubDate>Sun, 10 May 2015 16:10:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/05/10/git-f%C3%BCr-einsteiger-teil-4-github-edition/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://svij.org/blog/2015/01/12/git-fur-einsteiger-teil-3/&#34;&gt;Im letzten Teil&lt;/a&gt; ging es um das Rebasen und das Einrichten und Nutzen von
Remote-Repositorys. In diesem Teil wird es rein um GitHub und dessen Workflow gehen. Darunter
fällt unter anderem das Erstellen eines Repositorys und wie man sich an Open-Source-Projekten
auf GitHub beteiligen kann.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Dieses Tutorium besteht aus vier Teilen. Wem das Tutorium gefällt und mehr über
Git lernen möchte, der kann sich das Buch &lt;a href=&#34;https://amzn.to/3q0A5Iu&#34;&gt;„Versionsverwaltung mit Git“&lt;/a&gt;
für 29,99€ bestellen. In diesem Buch, was ich geschrieben habe, werden die Themen rund um Git noch
deutlich ausführlicher behandelt.&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;was-ist-github&#34;&gt;Was ist GitHub?&lt;/h3&gt;
&lt;p&gt;Im dritten Teil dieses Tutoriums wurde zwar erläutert wie man mit Remote-Repositorys
arbeitet, allerdings fehlte bislang eine sinnvolle Möglichkeit um Repositorys
auf entfernt liegenden Servern zu lagern, die man über das öffentliche Internet
erreichen kann. Eines der Dienste um dies zu erledigen ist &lt;a href=&#34;https://github.com&#34;&gt;GitHub&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;GitHub besitzt sehr viele Funktionen die sich um das kollaborative
Arbeiten an Projekten mit Git drehen. Darüber hinaus besitzt GitHub zwar noch einige weitere
Dienste, dieser Teil des Tutorium dreht sich allerdings mehr um die grundsätzlichen
Funktionen, die Git betreffen.&lt;/p&gt;
&lt;p&gt;Hinweis: Da GitHub stetig weiterentwickelt wird, ändert sich auch die Web-Oberfläche.
Die in diesem Artikel enthaltenen Screenshots könnten bereits nach wenigen Monaten veraltet
sein.&lt;/p&gt;
&lt;h3 id=&#34;repository-anlegen&#34;&gt;Repository anlegen&lt;/h3&gt;
&lt;p&gt;Bei GitHub können Git-Repositorys angelegt werden. Bevor man sein
erstes Repository anlegen kann, muss man sich zunächst registrieren. Der
Funktionsumfang mit einem Standardkonto ist auf öffentliche Git-Repositorys
beschränkt, das heißt vor allem, dass alle Dateien aus den Repositorys öffentlich
und somit für jeden lesbar sind. Gegen Bezahlung kann man auch private Repositorys anlegen.&lt;/p&gt;
&lt;p&gt;Nach der Registrierung und dem Einloggen findet man in der oberen Leiste in
GitHub diverse Bedienelemente, darunter auch ein Knopf um ein neues Repository
bzw. eine neue Organisation anzulegen. Eine Organisation ist an dieser Stelle
noch nicht so wichtig, kurz gesagt, kann man Organisationen anlegen, damit
eine Gruppe an Entwicklern sich die Rechte an Repositorys teilen können. Wenn
man hingegen einen Account als normalen Nutzer besitzt, sind die Rechte standardmäßig
auf die eigenen Repositorys für sich alleine beschränkt.&lt;/p&gt;
&lt;p&gt;Wenn man nun ein Repository anlegen möchte, muss man dem Repository zunächst einen
Namen vergeben. Optional ist hingegen eine kurze Beschreibung. Als zusätzliche
Möglichkeit, kann man dem Repository direkt eine README-Datei hinzufügen lassen,
ebenso wie eine &amp;ldquo;.gitignore&amp;rdquo;-Datei sowie eine Datei mit den Lizenz-Bestimmungen
des Projektes im Repository.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git4-neues-repo.webp&#34; data-lightbox=&#34;image&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/git4-neues-repo.webp&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Die &amp;ldquo;README&amp;rdquo;-Datei ist dafür da, um Informationen über das Projekt bzw. das Repository
auf der Startseite des Repositorys darzustellen. GitHub stellt dies automatisch
dar.&lt;/p&gt;
&lt;p&gt;In diesem Tutorium wurde bislang noch nicht die Datei &amp;ldquo;.gitignore&amp;rdquo; behandelt.
Innerhalb jedem Repositorys kann eine solche Datei anlegt werden. Alles was man
dort einträgt, wird von Git schlicht ignoriert und somit nicht weiter beobachtet. Wenn
man etwa an LaTeX-Dokumenten arbeitet, hat man bei jedem Kompilieren der TeX-Datei
einige Dateien, die nicht direkt für das Projekt selbst relevant sind und somit
auch eine Versionierung nicht notwendig ist. Diese Dateien kann man in der Datei
&amp;ldquo;.gitignore&amp;rdquo; eintragen und Git zeigt diese Dateien in keinen der Befehle an.
GitHub macht das Anlegen der Datei noch ein wenig komfortabler, da es sehr viele
vordefinierte gitignore-Dateien anbietet, etwa für Java-, Android- oder TeX-Projekte.&lt;/p&gt;
&lt;p&gt;Weiterhin kann man beim Anlegen eines Repositorys über GitHub eine Lizenz-Datei
anlegen lassen. Dies ist wichtig, damit auch
andere Leute von dem Inhalt des Repositorys profitieren können.&lt;/p&gt;
&lt;p&gt;Wenn man nun einen Namen, eine Beschreibung sowie eine Lizenz-Datei ausgewählt
hat und anschließend das Repository erzeugt, dann besitzt das Repository zu Beginn
genau einem Commit mit der Commit-Message „Initial Commit“.&lt;/p&gt;
&lt;h3 id=&#34;ssh-key-anlegen-und-hinzufügen&#34;&gt;SSH-Key anlegen und hinzufügen&lt;/h3&gt;
&lt;p&gt;Bevor man das neu angelegte Repository klonen kann, muss man dem GitHub-Account
noch einen SSH-Key hinzufügen. Sofern man auf dem lokalen Rechner noch kein
SSH-Key erzeugt hat, muss zunächst ein Key anlegt werden.&lt;/p&gt;
&lt;p&gt;Falls man nicht weiß, ob man schon mindestens einen SSH-Key besitzt, kann man
den Inhalt vom Ordner &amp;ldquo;~/.ssh&amp;rdquo; überprüfen. Ein SSH-Key setzt sich aus
zwei Dateien zusammen. Dies ist zum einen der private und zum anderen
der öffentliche Schlüssel. Beispielsweise ist die Datei &amp;ldquo;id_rsa&amp;rdquo; der private Schlüssel,
während &amp;ldquo;id_rsa.pub&amp;rdquo; öffentlicher Schlüsselteil ist.&lt;/p&gt;
&lt;p&gt;Sofern man noch keinen SSH-Key angelegt hat, kann man das mit dem folgenden Befehl
erledigen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ ssh-keygen -t rsa -C &amp;quot;mail@svij.org&amp;quot;
Generating public/private rsa key pair.
Enter file in which to save the key (/home/sujee/.ssh/id_rsa): /home/sujee/.ssh/id_github
Enter passphrase (empty for no passphrase): 
Enter same passphrase again: 
Your identification has been saved in /home/sujee/.ssh/id_github.
Your public key has been saved in /home/sujee/.ssh/id_github.pub.
The key fingerprint is:
SHA256:LFM8YkUe+ACh4+mH0GXZ4xAlWXT3zpHDEKdg/r9jBHI mail@svij.org
The key&#39;s randomart image is:
+---[RSA 2048]----+
|    =B+oB +..    |
|   ..=oB + * .   |
|  o = =o. . *    |
| o = + =ooEo o   |
|. +   + So..o    |
| o .   o   ..    |
|  o .      ..    |
|   .        o.   |
|           ...   |
+----[SHA256]-----+
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Beim Ausführen des gelisteten Befehls werden interaktiv einige Fragen gestellt,
die beantwortet werden sollten. Darunter den exakten Speicherort des Schlüssels,
sowie ein Passwort. Man kann zwar auch einen Schlüssel ohne Passwort generieren,
dies ist allerdings nicht empfehlenswert, da man sonst vollständigen Zugriff auf
die Repositorys erhält, falls der private Schlüssel in falsche Hände gerät.&lt;/p&gt;
&lt;p&gt;Nachdem nun das Schlüsselpaar generiert worden ist, muss nun der öffentliche
Schlüssel in GitHub eintragen werden. Der öffentliche Schlüssel liegt in diesem Beispiel
in &amp;ldquo;~/.ssh/id_github.pub&amp;rdquo;. In den &lt;a href=&#34;https://github.com/settings/ssh&#34;&gt;GitHub-SSH-Einstellungen&lt;/a&gt;
muss dann der Inhalt dieser Datei eingefügt werden.&lt;/p&gt;
&lt;h3 id=&#34;repository-klonen&#34;&gt;Repository klonen&lt;/h3&gt;
&lt;p&gt;An dieser Stelle kann man das Repository erstmals klonen. Dazu braucht man
die URL, um es über SSH zu klonen. Dies findet man entweder auf der GitHub-Repository-Seite
oder man setzt es sich selbst zusammen, da es immer dem gleichen Schema folgt.
In meinem Beispiel heißt das Repository „drunken-nemesis“ im Nutzer-Konto „svijee“.
Das Repository findet sich daher unter &lt;a href=&#34;https://github.com/svijee/drunken-nemesis&#34;&gt;https://github.com/svijee/drunken-nemesis&lt;/a&gt;.
Unter der rechten Seitenleiste auf GitHub findet sich die URL zum Klonen via SSH, HTTPS oder
Subversion. Relevant ist in der Regel nur das Klonen via SSH.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git4-repo-ansicht.webp&#34; data-lightbox=&#34;image&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/git4-repo-ansicht.webp&#34;&gt;
&lt;/a&gt;
&lt;pre&gt;&lt;code&gt;$ git clone git@github.com:svijee/drunken-nemesis.git
Klone nach &#39;drunken-nemesis&#39;...
Enter passphrase for key &#39;/home/sujee/.ssh/id_github&#39;: 
remote: Counting objects: 3, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Empfange Objekte: 100% (3/3), Fertig.
Prüfe Konnektivität... Fertig.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man das Repository direkt klont, konfiguriert Git automatisch das geklonte
Repository als das „origin“ Remote-Repository. Dies kann man nachvollziehen, wenn man in das
Verzeichnis wechselt und dort die Remote-Repositorys auflistet.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ cd drunken-nemesis
$ git remote -v
origin  git@github.com:svijee/drunken-nemesis.git (fetch)
origin  git@github.com:svijee/drunken-nemesis.git (push)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann man alle gewünschten Funktionen von Git nutzen, wie das Erstellen
von Branches und Commits. Diese können dann anschließend gepusht werden, um die
Änderungen über GitHub zur Verfügung zustellen. Die Änderungen lassen sich auch
auf der Webseite von GitHub selbst ansehen, sodass man Repositorys nicht zwangsläufig
klonen muss. Unter &lt;a href=&#34;https://github.com/svijee/drunken-nemesis/commits/master&#34;&gt;github.com/svijee/drunken-nemesis/commits/master&lt;/a&gt;
finden sich etwa alle Commits die auf dem Branch &amp;ldquo;master&amp;rdquo; getätigt wurden. Ebenfalls
kann man dort zwischen den Branches wechseln.&lt;/p&gt;
&lt;h3 id=&#34;github-workflow&#34;&gt;GitHub-Workflow&lt;/h3&gt;
&lt;p&gt;Das Besondere an GitHub ist, dass es nicht nur eine einfache Möglichkeit bietet
eigene Git-Repositorys zu hosten, sondern auch, dass man mit wenigen Schritten
Änderungen an Repositorys von anderen Personen oder Organisationen vorschlagen
kann, die dann übernommen werden können.&lt;/p&gt;
&lt;p&gt;Jedes GitHub-Repository lässt sich im Browser forken. Bei einem Fork spricht man
von einer Abspaltung. Hin und wieder hört man bei größeren Open-Source-Projekten,
das ein Fork entstanden ist. So ist die Büro-Suite LibreOffice ein Fork von OpenOffice.org, wo
allerdings nicht die Änderungen zu OpenOffice.org zurückgeflossen sind. Bei GitHub
hat ein Fork in der Regel eine etwas andere Bedeutung. In der Regel liegen die
Zugriffsberechtigungen an einem Repository allein bei dem Besitzer des Repositorys.
Über GitHub kann man nun Änderungen an einem Repository vorschlagen, dazu muss
man den Fork-Button im Browser drücken. Dann wird eine Kopie (der Fork) des Repositorys
erzeugt und im eigenen Account abgelegt. Dort besitzt man anschließend alle
nötigen Schreibrechte. Wenn man also an dem Repository &lt;a href=&#34;https://github.com/svijee/drunken-nemesis&#34;&gt;svijee/drunken-nemesis&lt;/a&gt;
Änderungen vorschlagen möchte, erstellt GitHub nach dem Drücken des Fork-Buttons
eine Kopie des Repositorys unter $DEINNAME/drunken-nemesis. GitHub zeigt selbst
direkt auch an, dass es sich um einen Fork des Haupt-Repositorys handelt.&lt;/p&gt;
&lt;p&gt;An dem Fork kann man nun wie gewünscht auf einem Branch die gewünschten Änderungen
in Form von Commits durchführen. In der Regel bietet es sich an, dafür einen extra
Branch anzulegen in dem man die Commits hinzufügt. Fehlen darf dafür natürlich kein
Beispiel:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git clone git@github.com:$DEINUSERNAME/drunken-nemesis.git
$ cd drunken-nemesis
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann man etwa eine Datei namens &amp;ldquo;README&amp;rdquo; mit beliebigen Inhalt
hinzufügen, die anschließend commited werden kann.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add README
$ git commit -m &amp;quot;README Datei hinzugefügt.&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Zur Wiederholung: Wichtig ist an diesem Punkt, dass man nicht vergisst das Repository
zu GitHub zu pushen. Da Git bekanntlich ein verteiltes Versionsverwaltungssystem
ist, sind die Änderungen bis zu diesem Punkt nur lokal verfügbar. Daher muss man
noch &amp;ldquo;git push&amp;rdquo; ausführen, um die Änderungen zu dem Remote-Repository auf GitHub zu
übertragen.&lt;/p&gt;
&lt;p&gt;Anschließend kann man über GitHub den sogenannten Pull-Request erstellen, in dem
man die Änderungen die man gemacht hat, dem Haupt-Repository zur Übernahme vorschlägt.
Bei jedem Repository, wo die Pull-Request-Funktion nicht abgeschaltet wurde, findet
sich auf der Repository-Seite der Menüpunkt &lt;a href=&#34;https://github.com/svijee/drunken-nemesis/pulls&#34;&gt;„Pull Requests“&lt;/a&gt;
auf der sich vorhandene, offene Pull-Requests befinden und auch neue angelegt
werden können. Beim Anlegen müssen dann beide Branches, jeweils aus dem Quell-
und Ziel-Repository, ausgewählt werden, die zunächst verglichen werden können.
Sofern alle benötigten Änderungen in dem Pull-Request enthalten sind, kann der
Request angelegt werden. Die Mitarbeiter an dem Haupt-Repository, an dem der Pull-Request
gestellt wurde, können diesen Kommentieren oder direkt annehmen.&lt;/p&gt;
&lt;h4 id=&#34;arbeiten-mit-zwei-remote-repositorys&#34;&gt;Arbeiten mit zwei Remote-Repositorys&lt;/h4&gt;
&lt;p&gt;Wenn man regelmäßig an einem Projekt über GitHub beiträgt, bietet sich eine
lokale Konfiguration an, die das Arbeiten mit zwei Remote-Repositorys erleichtert.
Dadurch, dass man letztendlich mit zwei Repositorys arbeitet, müssen beide
korrekt verwaltet werden. So gibt es einmal das eigene Repository, in dem man
Schreibrechte besitzt und das Repository des Projektes, wohin die Pull-Requests
und auch anderen Änderungen des Projektes fließen. Man sollte daher immer beachten,
dass man sein eigenes Repository auf dem eigenen Stand hält.&lt;/p&gt;
&lt;p&gt;Wenn die oben aufgeführten Befehle ausgeführt hat, ist der eigene Fork als Remote-Repository
&amp;ldquo;origin&amp;rdquo; konfiguriert. Dies sollte man genau so belassen, da man alle Branches
in das eigene Repository pusht. Jetzt sollte man das Repository des Projektes ebenfalls
als Remote-Repository hinzufügen, hier bietet es sich an, es &amp;ldquo;upstream&amp;rdquo; zu nennen,
da es sich schließlich um das Upstream-Projekt handelt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote add upstream git@github.com:svijee/drunken-nemesis.git
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Jetzt ist zwar das Repository konfiguriert, allerdings sind die Änderungen noch nicht
heruntergeladen. Dies kann man mit einem der beiden aufgeführten Befehle durchführen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote update 
$ git fetch upstream 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Während der erste Befehl alle Remote-Repositorys herunterlädt, lädt letzterer
Befehl nur das Remote &amp;ldquo;upstream&amp;rdquo; herunter. In der Regel ist es nun so, dass sich
auf dem Upstream-Repository einiges tut, diese Änderungen müssten dann regelmäßig
in das eigene Repository übernommen werden. Dazu sollte man regelmäßig &amp;ldquo;git remote update&amp;rdquo;
ausführen und anschließend den Branch aus dem Remote-Repository in den Branch des eigenen
Repositorys mergen. In diesem Beispiel, ist es der Branch &amp;ldquo;master&amp;rdquo; den man
aktualisieren möchte.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git merge upstream/master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Sofern keine Änderungen auf dem Branch &amp;ldquo;master&amp;rdquo; im eigenen Repository sind, sollte
der Merge problemlos funktionieren. Änderungen, die man dem Haupt-Repository beifügen
will, sollte man daher immer in einem neuen Branch anlegen, um Merge-Konflikte
zu vermeiden.&lt;/p&gt;
&lt;p&gt;Häufig passiert es aber auch, dass man Pull-Requests anlegt, die zu einem späteren
Zeitpunkt nicht mehr automatisch ohen Konflikte gemergt werden können. Als Einreicher
von Pull-Requests sollte man also immer darauf achten, dass der Pull-Request ohne
Konflikte gemergt werden kann. Da dies nicht immer möglich ist, müssen gegebenfalls
Commits aus dem Entwicklungs-Branch des Haupt-Repositorys übernommen werden. Diese
kann man entweder mit dem &amp;ldquo;git merge&amp;rdquo; Befehl mergen, schöner ist es allerdings, wenn
man ein Rebase durchführt, der im dritten Teil dieses Tutoriums erläutert wurde.&lt;/p&gt;
&lt;h3 id=&#34;weitere-funktionen-von-github&#34;&gt;Weitere Funktionen von GitHub&lt;/h3&gt;
&lt;p&gt;GitHub bietet nicht nur das Hosten von Repositorys an. Die Funktionen sind mittlerweile
vielfältig und decken so gut wie alle Wünsche ab, die man für ein Software-Projekt
haben kann. Darunter ein Ticket-System („Issues“) und ein Wiki. Beides ist direkt
über das Repository zu erreichen. Daneben kann man auch statische Webseiten
mit &lt;a href=&#34;https://pages.github.com/&#34;&gt;GitHub Pages&lt;/a&gt; hosten oder &lt;a href=&#34;https://gist.github.com&#34;&gt;Gists&lt;/a&gt;
als Lager für einzelne Dateien anlegen.&lt;/p&gt;
&lt;h3 id=&#34;alternativen&#34;&gt;Alternativen&lt;/h3&gt;
&lt;p&gt;GitHub ist nicht die einzige Plattform, welche das Hosten von Repositorys mit
sinnvollen Features erweitert um einfach und kollaborativ an Projekten zu arbeiten.
So hat GitHub auch Nachteile, etwa steht es selbst nicht unter eine Open Source
Lizenz und das Hosten von privaten, nicht öffentlichen Repositorys kostet Geld.&lt;/p&gt;
&lt;p&gt;Als Alternative seien &lt;a href=&#34;https://about.gitlab.com/&#34;&gt;Gitlab&lt;/a&gt; und &lt;a href=&#34;https://bitbucket.org/&#34;&gt;Bitbucket&lt;/a&gt;
genannt, bei denen man auch private Repositorys mit einigen Begrenzungen kostenlos hosten kann. Gitlab
kann man aber auch selbst auf eigenen Servern hosten, sodass man etwa für den
Firmen-internen Gebrauch von Closed Source Software den Quellcode nicht auf
fremde Server hochladen muss.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/&#34;&gt;Hier geht es zu Teil 1&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2014/11/01/git-fur-einsteiger-teil-2/&#34;&gt;Hier geht es zu Teil 2&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2015/01/12/git-fur-einsteiger-teil-3/&#34;&gt;Hier geht es zu Teil 3&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Git Tip #1: Sub-Directorys, Single-Branches und Repositorys ohne Historie ausschecken</title>
      <link>https://svij.org/blog/2015/03/31/git-tip-1-sub-directorys-single-branches-und-repositorys-ohne-historie-ausschecken/</link>
      <pubDate>Tue, 31 Mar 2015 16:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/03/31/git-tip-1-sub-directorys-single-branches-und-repositorys-ohne-historie-ausschecken/</guid>
      <description>&lt;p&gt;Bevor meine Git-Tutorial Reihe weiter geht, fange ich mal eine kleine neue
Reihe an. In dieser „Git Tip“-Reihe werde ich hin und wieder mal, das ein
oder andere kleine Git-Feature oder Problem beleuchten und wie man es lösen kann. Meistens wohl dann, wenn ich selbst auf ein Problem stoße.&lt;/p&gt;
&lt;p&gt;Vor allem in der Qualitätssicherung kommt es häufiger vor, dass man ein Repository
mit nur einen Branch klonen will, ein Repository gänzlich ohne
Historie klonen will oder nur ein Sub-Directory klonen will.&lt;/p&gt;
&lt;p&gt;Der erste Punkt ist recht einfach zu lösen. Der folgende Befehl klont genau einen Branch:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# git clone &amp;lt;url&amp;gt; --branch &amp;lt;branchname&amp;gt; --single-branch
git clone git@github.com:svijee/taskwarrior-androidapp.git --branch master --single-branch
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie man sieht, bringt diese Funktion Git selbst mit. Es ist also kein wirkliches Problem.&lt;/p&gt;
&lt;p&gt;Auch das Klonen eines Repositorys &lt;em&gt;ohne&lt;/em&gt; Versionshistorie lässt sich mit den Boardmitteln lösen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# git clone --depth 1 --branch &amp;lt;branch&amp;gt; &amp;lt;url&amp;gt;
git clone --depth 1 --branch master git@github.com:svijee/taskwarrior-androidapp.git
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In diesem Fall wird nur der aktuelle Stand des Repositorys aus dem Branch „master“ geklont. Je nachdem wie viele Revisionen man aus der Versionshistorie möchte, kann man den Parameter &amp;ldquo;depth&amp;rdquo; entsprechend anpassen. Man kann die Historie auch ganz einfach prüfen, in dem man ein nachfolgendes &amp;ldquo;git log&amp;rdquo;
ausführt, welches nur einen Commit anzeigen sollte:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git log
commit 098c0fd18317ad3abe4ecad3a007ff6a6dcd501b
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Fri Sep 19 21:19:40 2014 +0200

    Upgraded compileSdkVersion from 19 to 20
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anders sieht es allerdings aus, wenn man nur einen Unterordner klonen will. Dies ist nicht direkt mit Git selbst möglich, hier muss man sich ein wenig „tricksen“.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;# git archive --remote=&amp;lt;url&amp;gt; &amp;lt;branch&amp;gt; &amp;lt;sub-dir&amp;gt; | tar xvf -
git archive --remote=git@github.com:svijee/taskwarrior-androidapp.git master taskwarrior | tar xvf -
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Hier wird der Befehl „git archive“ „missbraucht“, um einen Unterorder zu klonen. Der Befehl „git archive“ ist dafür da, aus dem Git-Repository ein Tar-Archiv zu erzeugen. Dieser kann allerdings auch Tarball aus einem Unterverzeichnis erstellen. Mit einer Pipe kann man sich den Ordner dann auch direkt und ohne Umwege auf die Festplatte schreiben lassen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Mehr Freifunk!</title>
      <link>https://svij.org/blog/2015/02/28/mehr-freifunk/</link>
      <pubDate>Sat, 28 Feb 2015 11:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/28/mehr-freifunk/</guid>
      <description>&lt;p&gt;Im August 2014 habe ich &lt;a href=&#34;https://svij.org/blog/2014/08/10/mein-erster-freifunk-knoten/&#34;&gt;meinen ersten Freifunk-Knoten&lt;/a&gt;
bei mir Zuhause aufgestellt. Mittlerweile hat sich einiges getan und auch bei
mir steht jetzt ein zusätzlicher zweiter Router.&lt;/p&gt;
&lt;p&gt;Beide Freifunk-Router laufen über &lt;a href=&#34;http://freifunk-ruhrgebiet.de/&#34;&gt;Freifunk-Ruhrgebiet&lt;/a&gt;.
Interessant ist, dass Freifunk letzten August vorallem im Ruhrgebiet kaum verbreitet
war. So gab es insgesamt um die 100 Knoten und in Dortmund etwa gar keine Freifunk-Nodes.
Mittlerweile sind einige Knoten dazugekommen. Alleine im &lt;a href=&#34;http://map.freifunk-ruhrgebiet.de/counts/&#34;&gt;Ruhrgebiet&lt;/a&gt; finden sich über 1000 Knoten.&lt;/p&gt;
&lt;p&gt;Ich selbst habe im vorherigen Artikel beschrieben, wie man ein privates
WLAN-Netz mit dem Freifunk-Images aufsetzen kann. Mittlerweile ist das nicht mehr
notwendig, da es im offiziellen Image eingeflossen ist und man es über das Web-Interface
konfigurieren kann.&lt;/p&gt;
&lt;p&gt;Das Freifunk-Netz nutze ich selbst eher selten, stattdessen scheint es der
ein oder andere Nachbar zu nutzen, schließlich gab es über meinen Router
einen Traffic-Volumen von ~26,5 GB in den letzten 37 Tagen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/freifunk1.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Meine beiden Freifunk-Knoten.&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/freifunk1.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Freifunk fungiert bei mir größtenteils als Gäste-WLAN. Die Router eignen sich
gleichzeitig eben auch, um das eigene private WLAN-Netz im Haus zu erweitern. Diesmal
griff ich zu einem TP-Link WDR3600 für knapp 35€. Jetzt ist auch im ganzen Haus
überall sowohl mein privates WLAN-Netz als auch Freifunk verfügbar.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/freifunk2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Meine beiden Freifunk-Knoten beim meshen.&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/freifunk2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Wer Freifunk nicht kennt, der kann auf einen der zahlreichen Freifunk-Communities
nachlesen, etwa auch bei &lt;a href=&#34;http://freifunk-ruhrgebiet.de/&#34;&gt;Freifunk-Ruhrgebiet&lt;/a&gt;.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>ShareLaTeX und minted auf dem eigenen Server</title>
      <link>https://svij.org/blog/2015/02/27/sharelatex-und-minted-auf-dem-eigenen-server/</link>
      <pubDate>Fri, 27 Feb 2015 19:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/27/sharelatex-und-minted-auf-dem-eigenen-server/</guid>
      <description>&lt;p&gt;Ihr kennt das sicherlich: Es gibt Probleme bei denen man stundenlang nach einer
Lösung sucht. Ich selbst stand diese Woche vor einem Problem: In einem LaTeX-Dokument
wollte ich das Paket &amp;ldquo;minted&amp;rdquo; nutzen. Minted ist dafür da, um Quellcode innerhalb
eines LaTeX-Dokumentes automatisch zu syntax-highlighten. Ich selbst nutzte dabei
allerdings nicht eine lokale LaTeX-Installation, sondern ShareLaTeX. Eine ausführliche
&lt;a href=&#34;https://svij.org/blog/2015/01/11/kollaborativ-an-latex-dokumenten-arbeiten-mit-sharelatex/&#34;&gt;Installations-Anleitung zu ShareLaTeX&lt;/a&gt;
habe ich im Januar veröffentlicht. Um nun das LaTeX-Dokument mit &amp;ldquo;minted&amp;rdquo; zu
kompilieren, muss man lokal folgenden Befehl ausführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ pdflatex --shell-escape main.tex
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Lokal ist das natürlich kein Problem. Wenn man hingegen ShareLaTeX nutzt, kann
man diesen Aufruf nicht so einfach anpassen. Das Argument &amp;ldquo;&amp;ndash;shell-escape&amp;rdquo; wird
benötigt, da ein externes Programm ausgeführt wird. Da es ein potenzielles
Sicherheitsrisiko ist, ist es standardmäßig so konfiguriert.&lt;/p&gt;
&lt;p&gt;Ausschalten kann man das Verhalten in dem man die Datei &amp;ldquo;/usr/share/texlive/texmf-dist/web2c/texmf.cnf&amp;rdquo;
(unter Ubuntu) öffnet und dort &amp;ldquo;shell_escape = p&amp;rdquo; zu &amp;ldquo;shell_escape = t&amp;rdquo; ändert.
Anschließend lassen sich auch in ShareLaTeX Dokumente mit dem minted Paket
problemlos kompilieren.&lt;/p&gt;
&lt;p&gt;Witzig ist auch, dass ich dann auf einen weiteren Fehler gestoßen bin. ShareLaTeX
mag es nicht, wenn die &amp;ldquo;main.tex&amp;rdquo; &lt;strong&gt;nicht&lt;/strong&gt; im Hauptverzeichnis des Projektes
liegt. Wenn es in einem Unterordner befindet, dann lässt sich ggf. das Dokument
nicht kompilieren. Immerhin gibt es dazu &lt;a href=&#34;https://github.com/sharelatex/sharelatex/issues/171&#34;&gt;auch ein Ticket&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Fun-Fact: Beim Suchen nach einer Lösung zu genau diesem Problem, habe ich mich
lustigerweise auch auf meinem Blog verirrt. Wenigstens beim nächsten Mal finde
ich hier die Lösung.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Chemnitzer Linux-Tage…</title>
      <link>https://svij.org/blog/2015/02/27/chemnitzer-linux-tage/</link>
      <pubDate>Fri, 27 Feb 2015 19:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/27/chemnitzer-linux-tage/</guid>
      <description>&lt;p&gt;Am 21. und 22. März finden die Chemnitzer Linux-Tage statt. Ich selbst bin diesmal
erstmals auch dort am Start. Das &lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/plan&#34;&gt;Programm&lt;/a&gt;
der Veranstaltung ist breit gefächert. Immerhin sechs parallele Vorträge sowie
zusätzlich noch drei parallele &lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/workshops&#34;&gt;Workshops&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Ich selbst werde, wie bei fast jeder OpenSource-Messe die ich besuche, am Ubuntu-Stand
vertreten sein. Bis zur Veranstaltung werden wir auch mindestens eins, wahrscheinlich
eher zwei Ubuntu Phones dabei haben. Die wurden im letzten Jahr relativ häufig
angefragt.&lt;/p&gt;
&lt;p&gt;Vorträge werde ich auch Besuchen, konkret habe ich mir folgende rausgesucht,
die ich am Samstag höchstwahrscheinlich besuchen werde: &lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/306&#34;&gt;Git Workflows im Alltag&lt;/a&gt;, &lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/271&#34;&gt;Aktuelle Entwicklungen im Linux-Kernel&lt;/a&gt;,
&lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/248&#34;&gt;Qt: ein Code, alle Betriebssysteme&lt;/a&gt;,
&lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/194&#34;&gt;An introduction to Amazon Web Services&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Am Sonntag plane ich wenigere Vorträge, nämlich: &lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/441&#34;&gt;Docker&lt;/a&gt;,
&lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/303&#34;&gt;Embedded Web mit Django&lt;/a&gt;
und eventuell noch &lt;a href=&#34;https://chemnitzer.linux-tage.de/2015/de/programm/beitrag/269&#34;&gt;Admin&amp;rsquo;s Diary: Wie ich lernte, systemd zu lieben ;-)&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Wer übrigens eine gute Bus-Verbindung nach Chemnitz sucht, der wird vielleicht
auf &lt;a href=&#34;http://freedom-tours.de/&#34;&gt;Freedom Tours&lt;/a&gt;, dem quasi „Linux-Bus“, eine Fahrt
finden. Jedenfalls fahre ich mit dem Bus direkt nach Chemnitz. Je mehr Leute
mitfahren, desto günstiger wird es. &lt;a href=&#34;http://freedom-tours.de/letztes-hotelbett-weg/531&#34;&gt;Plätze sind aber noch frei!&lt;/a&gt;&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ubuntu Phone und ich bei RadioTux</title>
      <link>https://svij.org/blog/2015/02/26/ubuntu-phone-und-ich-bei-radiotux/</link>
      <pubDate>Thu, 26 Feb 2015 19:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/26/ubuntu-phone-und-ich-bei-radiotux/</guid>
      <description>&lt;p&gt;Am 6. Februar war ich beim &lt;a href=&#34;https://svij.org/blog/2015/02/09/impressionen-vom-ubuntu-phone-insider-event/&#34;&gt;Ubuntu Phone Insider Launch Event&lt;/a&gt;,
wo ich bekanntlich auch das Smartphone in die Hände bekommen habe. Mittlerweile
habe ich auch schon meinen langen Testbericht in Ikhaya &lt;a href=&#34;http://ubuntuusers.de/ikhaya/6623/&#34;&gt;veröffentlicht&lt;/a&gt;.
Es ist ziemlich lang geworden, also nehmt euch Zeit beim Lesen.&lt;/p&gt;
&lt;p&gt;Wer nicht so viel Lesen mag und lieber etwas hört, dem kann ich die &lt;a href=&#34;http://www.radiotux.de/index.php?/archives/7994-RadioTux-Sendung-Februar-2015.html&#34;&gt;Februar-Ausgabe&lt;/a&gt; von RadioTux empfehlen. Zu Beginn erzählt
Leszek von Tizen und das erste Tizen Smartphone, dem Samsung Z1. Im zweiten Teil,
ab 1:08:53 melde ich mich zu Wort. Mit Ingo habe ich dann über das Launch Event
in London, über das System, sowie über das Smartphone selbst gesprochen.&lt;/p&gt;
&lt;p&gt;Für mich war es das erste Mal bei einem Podcast. Da ich selbst nur ein relativ
günstiges Mikrofon bzw. Headset besitze, ist die Sound-Qualität dementsprechend
nicht allzu gut. Zu Beginn war ich vorallem nervös, das hat sich hinterher mehr
oder minder gelegt. Bitte verzeiht mir übrigens die vielen &amp;ldquo;ähms&amp;rdquo; ;-). Insgesamt beträgt
die Länge meines Segments über Ubuntu Phone etwa eine Stunde. Inhaltlich habe ich
größtenteils nicht viel neues erzählt, sofern man meine Blog-Posts und Ikhaya-Artikel
bereits gelesen hat.&lt;/p&gt;
&lt;p&gt;Viel Spaß beim Hören!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Fragen und Antworten zu Ubuntu Phone</title>
      <link>https://svij.org/blog/2015/02/16/fragen-und-antworten-zu-ubuntu-phone/</link>
      <pubDate>Mon, 16 Feb 2015 19:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/16/fragen-und-antworten-zu-ubuntu-phone/</guid>
      <description>&lt;p&gt;Am 5. Februar hatte ich in &lt;a href=&#34;https://svij.org/blog/2015/02/05/ubuntu-phone-insider-event-in-london-am-6-februar/&#34;&gt;einem Artikel&lt;/a&gt;
meinen Besuch beim „Ubuntu Phone Insider Launch Event“ angekündigt. Dort habe
ich angeboten, dass ich offene Fragen zu Ubuntu Phone und zu dem bq Aquaris E4.5
beantworte. Einige E-Mails mit Fragen sind vor und auch kurz nach dem Event
eingetroffen. Zeit sie zu beantworten hatte ich bislang nicht sonderlich, weshalb
ich es hier mal tue.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Ist es möglich, Ubuntu Phone auf dem bq Aquaris E6 zu Installieren?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Nein, zumindest nicht offiziell. Der Hersteller bq hat gegenüber OMG! Ubuntu!
&lt;a href=&#34;https://twitter.com/omgubuntu/status/566981897893732353&#34;&gt;bestätigt&lt;/a&gt;, dass sie keine Pläne
für weitere Ubuntu Phones haben.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Erscheint ein Ubuntu Phone mit einem Display, welches größer ist als 4,5 Zoll?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Ja, das Meizu MX4 wird mit (u.a.) mit Ubuntu ausgeliefert. Siehe auch &lt;a href=&#34;https://svij.org/blog/2015/02/11/cristian-parrino-from-canonical-about-the-release-of-ubuntu-phone-and-future-plans/&#34;&gt;das Interview mit Cristian Parrino&lt;/a&gt;.
Erscheint März oder April.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Lässt sich der Akku vom bq tauschen?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Nein, dieser ist wie bei vielen anderen aktuellen Smartphones fest-verbaut. Ausnahmen betätigen die Regel.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Kann ich kontrollieren und/oder begrenzen, ob bzw. welche Daten eine
App versendet? Und an wen? Bzw. mir Beispiel-Datensätze anzeigen lassen?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Das ist leider nicht möglich.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Läuft das GPS unabhängig von WLAN- oder Mobilfunkzellen?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Es lässt sich in den Einstellungen die &amp;ldquo;Standortbestimmung&amp;rdquo; und &amp;ldquo;GPS&amp;rdquo; einzeln
aktivieren. Es scheint also für mich kein großer Unterschied zu den anderen
mobilen Betriebssystemen bezüglich A-GPS zu herrschen.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Kann man das Gerät dann in Castrop-Rauxel mal besichtigen?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Natürlich. :-)&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Kommt Meizu und LeTV auch nach Europa?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Meizu: ja. Von LeTV hab ich bis jetzt noch gar nichts gehört.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Ist es gerootet oder einfach rootbar, um apt-get nutzen zu können?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Man kann den Modus „umschalten“ sodass man apt-get nutzen kann. Empfohlen wird
das allerdings nicht, da man dann keine System-Updates erhält, da diese Image-basiert
ausgeliefert werden.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Wird das BQ mit neu geflashten Versionen später auch als PC am
Bildschirm benutzbar sein?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Nein.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Gibt es eine Möglichkeit ein Hotspot zu erstellen?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Nein, auch das gibt es leider nicht.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Wie will eine offene Navi-Software ernsthaft mit Google Maps konkurrieren?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Diese Frage lässt sich eher schwierig beantworten. HERE Maps ist vorinstalliert,
bietet allerdings zum jetzigen Zeitpunkt keine Turn-by-Turn Navigation.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Wie kontaktiere ich meine WhatsApp-Freunde ohne Client?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Garnicht. Einen WhatsApp Client gibt es zur Zeit nicht. Stattdessen ist der
Messenger &lt;a href=&#34;https://telegram.org/&#34;&gt;Telegram&lt;/a&gt; verfügbar.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Wird Ubuntu den Weg von Tizen gehen und eine Möglichkeit anbieten, Android-Apps zu nutzen, oder muss auf all die bekannteren und unbekannteren Apps der Android-Welt verzichtet und darauf gehofft werden, dass gute Alternativen entwickelt werden?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Eine Unterstützung von Android Apps ist nicht vorhanden und wird auch nicht kommen.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Warum werden die Ubuntu Phones nicht normal über den Store verkauft?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Meine Meinung: Marketing. Durch häufigere Flash-Sales bleibt Ubuntu Phone
häufiger im Gespräch, als wenn es „leise“ in den Verkauf geht. Natürlich mit allen
Vor- und Nachteilen die ein Flash-Sale mit sich bringt. bq hat auf &lt;a href=&#34;https://twitter.com/bqreaders/status/567013970733957120&#34;&gt;Twitter beantwortet&lt;/a&gt;, dass es eine Entscheidung von Canonical sei, auch wenn bq
die Geräte selbst verkauft.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Wird es später auch das E5 mit Ubuntu geben?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Nein, siehe oben.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Könnte man ein E4.5 kaufen und Ubuntu selbst installieren?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Ja, bq hat angekündigt Images bereitzustellen.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Im SDK hatte ich keinen E-Mail-Client gefunden, ist einer installiert?&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Nein. Es gibt allerdings die E-Mail App „Dekko“, die noch in Beta ist und noch
eingeschränkte Funktionen hat. So kann man nur den Posteingang abrufen, allerdings
keine anderen Ordner im IMAP-Konto. Daneben gibt es noch einige Stabilitätsprobleme.&lt;/p&gt;
&lt;p&gt;Das waren alle Fragen die ich bekam. Einige habe ich ausgelassen, wenn ich sie
etwa nicht beantworten konnte. Darunter waren zwei/drei technische Fragen.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Video Hands on bq Aquaris E4.5 Ubuntu Edition</title>
      <link>https://svij.org/blog/2015/02/16/video-hands-on-bq-aquaris-e45-ubuntu-edition/</link>
      <pubDate>Mon, 16 Feb 2015 18:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/16/video-hands-on-bq-aquaris-e45-ubuntu-edition/</guid>
      <description>&lt;p&gt;Nach knapp über eine Woche im Besitz des „bq Aquaris E4.5 Ubuntu Edition“, also
des ersten Ubuntu Phones, habe ich gestern ein kleines „Hands on“ Video aufgenommen.
In knapp 17,5 Minuten gebe ich dort einen Überblick in den Aufbau der graphischen
Oberfläche und die Gesten. Darunter auch ein genauer Blick auf die Scopes die
im Standard aktiviert sind. Ich konnte natürlich nicht alle Einzelheiten abdecken in dem
Video, denn sonst wäre es vorallem zu lang geworden.&lt;/p&gt;
&lt;p&gt;Ich denke, die meisten werden davon einen guten Einblick in das System bekommen,
wie es läuft, wie es funktioniert und wie die gängige Nutzung ausschaut. Das
Video habe ich &lt;a href=&#34;https://www.youtube.com/watch?v=k6SkaqtKtbg&#34;&gt;hier auf YouTube&lt;/a&gt;
hochgeladen.&lt;/p&gt;
&lt;iframe width=&#34;560&#34; height=&#34;315&#34; src=&#34;https://www.youtube.com/embed/k6SkaqtKtbg&#34; frameborder=&#34;0&#34; allowfullscreen&gt;&lt;/iframe&gt;
&lt;p&gt;Ein erster ausführlicher Test-Bericht folgt im Laufe dieser Woche.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Impressionen vom Ubuntu Phone Insider Event</title>
      <link>https://svij.org/blog/2015/02/09/impressionen-vom-ubuntu-phone-insider-event/</link>
      <pubDate>Mon, 09 Feb 2015 20:05:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/09/impressionen-vom-ubuntu-phone-insider-event/</guid>
      <description>&lt;p&gt;Wie auf meinem Blog &lt;a href=&#34;blog/2015/02/05/ubuntu-phone-insider-event-in-london-am-6-februar/&#34;&gt;angekündigt&lt;/a&gt;
fand am 6. Februar fand das „Ubuntu Phone Launch Insider Event“ in London statt.
Im &lt;a href=&#34;http://ubuntuusers.de/ikhaya/6568/&#34;&gt;Ikhaya auf ubuntuusers.de&lt;/a&gt; habe ich bereits
vorgestern einen kleinen Bericht veröffentlicht. Da ich dort keine persönlichen
Bemerkungen untergebracht habe, folgt hier nun ein etwas ausführlicherer Bericht.&lt;/p&gt;
&lt;h3 id=&#34;die-einladung&#34;&gt;Die Einladung&lt;/h3&gt;
&lt;p&gt;Die ursprüngliche Einladung zu dem Event erhielt ich von Daniel Holbach im August
2014. Immerhin schon ein halbes Jahr her. Damals war zunächst nur von einer
kostenlosen Zurverfügungstellung die Rede. Weshalb die ursprüngliche Einladung
von &lt;a href=&#34;http://ubuntuusers.de/user/toddy/&#34;&gt;Toddy&lt;/a&gt; an mich überging. Danke hierfür toddy!&lt;/p&gt;
&lt;p&gt;Später kam also dann die echte Einladung zum Event, allerdings noch ohne konkreten
Termin. Obwohl zunächst von Anfang Oktober die Rede war, verschob sich es immer
weiter, bis letztendlich im Dezember verkündet wurde, dass es am 6. Februar
stattfinden wird.&lt;/p&gt;
&lt;h3 id=&#34;die-anreise&#34;&gt;Die Anreise&lt;/h3&gt;
&lt;p&gt;Die Anreise und Unterkunft in London für das Event wurde komplett von Canonical bezahlt.
Dies umfasste für Europäer zwei Nächte in London und bis zu drei Nächte für
Teilnehmer aus den USA.&lt;/p&gt;
&lt;p&gt;Ich selbst reiste am Tag des Events, also am 6. Februar früh morgens an. Über
Google+ bin ich glücklicherweise am Vortag auf den Franzosen Vincent Jobard
aus der französischen Ubuntu-Community gestoßen, welcher zu ähnlicher Zeit
am Airport London-Heathrow landete wie ich, sodass wir uns gemeinsam auf dem Weg gemacht haben in die
Innenstadt von London.&lt;/p&gt;
&lt;p&gt;Wir hatten zwar keine Einladung zur Besichtigung der Canonical-Büros, doch haben
wir es auf gut Glück versucht. Wie erwartet, durften wir in der Tat die Büros
besichtigen. Dort trafen wir dann zufällig auf drei Mitgliedern der italienischen
Community, die ebenfalls zum Event eingeladen waren. Die Büros waren eher unspannend,
da es kaum mehr als zwei Großraumbüros sind in dem viele Leute sitzen. Interessant
und verwunderlich war für mich allerdings, dass dort verhältnismäßig viele Macs
standen, die mit Mac OS X liefen. Eine Vielzahl davon stand allerdings bei den
Designern. Man sollte allerdings nicht vergessen, dass die meisten Canonical-Mitarbeiter,
die an Ubuntu arbeiten, von zuhause arbeiten und nicht in den Londoner Büros.
Netterweise führte uns Alan Pope durch die Büros und erzählte ein wenig vom
Arbeiten bei Canonical.&lt;/p&gt;
&lt;p&gt;Anschließend ging es in das Hotel. Untergebracht waren alle Ubuntu-Community
Mitglieder im Hotel &lt;a href=&#34;http://www.lemeridienpiccadilly.co.uk/&#34;&gt;„Le Méridien“&lt;/a&gt;
direkt am Picadilly Circus. Laut Webseite kostet dort eine Nacht schlappe 300€.
Am Hotel versammelten sich so langsam fast alle eingeladenen Community-Mitglieder.
Insgesamt dürften dies zwischen 20 und 30 gewesen sein. Dabei waren Teilnehmer
aus Frankreich, Spanien, Italien, Finnland, USA und möglicherweise aus noch einigen
weiteren Ländern. Im Eingangsbereich fand dann auch eine kleine inoffizielle
Vorstellungsrunde statt mit den Kernfragen &amp;ldquo;Wie heißt du, wo kommst du her und
was machst du in der Ubuntu-Community?&amp;rdquo;.&lt;/p&gt;
&lt;h3 id=&#34;das-event&#34;&gt;Das Event&lt;/h3&gt;
&lt;p&gt;Um 13 Uhr Ortszeit fing das Treffen der Community an. Der Veranstaltungsort war
das Ham Yard Hotel in der Nähe von Picadilly Circus mitten in Londons Innenstadt.
Zu Beginn mussten sich alle eingeladenen Personen noch etwas gedulden, sodass
noch nicht direkt die Smartphones ausgehändigt wurden. Zunächst stand nämlich
das Mittagessen in Form von vielen kleinen Snacks an. In der Zwischenzeit konnten
sich Mitglieder von der Community untereinander oder mit Canonical-Mitarbeitern
unterhalten.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubuntuphone_lunch_klein.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Mittagessen.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/ubuntuphone_lunch_klein.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;a href=&#34;https://svij.org/graphics/ubuntuphone_event_klein.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Der Veranstaltungsraum.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/ubuntuphone_event_klein.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Nach etwa einer Stunde wechselten alle Anwesenden den Raum, in dem die offizielle
Veröffentlichung stattfand. Zunächst ergriff Cristian Parrino, Vice President
Mobile bei Canonical, das Wort. Dabei gab er einige Informationen über das
Telefon bekannt. So gibt es zwar (noch) kein WhatsApp für Ubuntu Phone, doch
gibt es den Messenger Telegram, welcher vorinstalliert ist. Der Verkauf des
Smartphones startet diese Woche, wann genau ist noch nicht bekannt. Die
genauen Daten werden über die Social-Media Kanäle von &lt;a href=&#34;http://twitter.com/ubuntu&#34;&gt;Ubuntu&lt;/a&gt;
und &lt;a href=&#34;http://twitter.com/bqreaders&#34;&gt;bq&lt;/a&gt; bekannt gegeben. Der Verkauf verläuft in
einem sogenannten Fire-Sale, sodass die Geräte nur innerhalb eines kurzen Zeitraums
käuflich zu erwerben sind. Sehr wahrscheinlich wird der Verkauf Dienstag oder Mittwoch
losgehen. Ebenfalls ergriff ein Mitarbeiter von bq das Wort und lobte
die gute Zusammenarbeit mit Canonical. Als dritte und letzte Person gab auch noch
Jane Silber sich die Ehre. Jane Silber stellte heraus, das Ubuntu großes Potenzial
auf dem Smartphone hat, da es „anders“ denkt. Dieses „anders“ umfasst insbesondere
die Existenz der sogenannten Scopes, welches nicht Apps sind, doch Informationen
aus verschiedenen Apps und Ressourcen aus dem Internet thematisiert zusammenfassen
und darstellen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubuntuphone_parrino_klein.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Cristian Parrino bei der Veröffentlichung.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/ubuntuphone_parrino_klein.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;So gibt es auf dem Home-Screen verschiedene Scopes, wie etwa den „Near By“-Scope
mit Informationen und Bildern aus der aktuellen Umgebung. Weiterhin gibt es unter
anderem auch noch Foto- und Video-Scopes, welche nicht nur die Dateien aus dem
Gerät darstellen, sondern auch aus Quellen wie YouTube oder Flickr ihre Daten beziehen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubuntuphone_box_klein.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Das Phone in der Box.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/ubuntuphone_box_klein.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;a href=&#34;https://svij.org/graphics/ubuntuphone_running.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Das Phone im Betrieb..&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/ubuntuphone_running.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Zum Schluss erfolgte die Übergabe der ersten Ubuntu Phones an die Mitglieder der
Community. Die Smartphones waren eingepackt in einer großen Box, in der nicht
nur das Smartphone selbst enthalten war, sondern ebenfalls Kopfhörer von Urbanears.
Mit dabei war ebenfalls ein Brief von Canonical-Gründer Mark Shuttleworth sowie
eine SIM-Karte inklusive 10 Pounds Aufladeguthaben. Die Box und dessen Inhalt ist
allerdings nur speziell an die Mitglieder der Community gerichtet und wird so nicht
in den Verkauf gehen. Die Verpackung war recht aufwendig, da das Smartphone in
einem Origami-Stil verpackt war.&lt;/p&gt;
&lt;p&gt;Anschließend folgte der Spaß, sodass jeder nicht nur mit dem Smartphone herumspielen konnte,
sondern es gab ebenfalls eine Bowling-Bahn im Veranstaltungsort. Ich selbst spielte
mit einem Griechen, Franzosen und einem Polen. Immerhin wurde ich nicht Letzter.
Mitgespielt haben nicht nur Community-Mitglieder sondern auch Cristian Parrino und Jane Silber
auf der Nachbarbahn.&lt;/p&gt;
&lt;p&gt;Am Abend löste sich die Gruppe allmählich auf, sodass ein großer Teil der Gruppe
verschiedene Pubs besucht hat.&lt;/p&gt;
&lt;h4 id=&#34;weitere-informationen&#34;&gt;Weitere Informationen&lt;/h4&gt;
&lt;p&gt;In einigen privaten Gesprächen auf der Veranstaltung haben die Verantwortlichen von
Canonical einige weitere Informationen mitgeteilt. So sollen auch weiterhin zuerst
ausgewählte Community-Mitglieder mit den neuesten Informationen versorgt werden,
bevor sie an die Presse gehen. Ebenfalls gab es Informationen zu dem ersten Smartphone
von Meizu. Hierbei handelt es sich um das Meizu MX4, welches deutlich leistungsstärker
ist als das bq Aquaris E4.5. Dieses soll im Idealfall nächsten Monat im März in China
und Europa erscheinen. Ein genauer Termin wurde allerdings noch nicht genannt.
Es kann durchaus sein, dass sich dieser Termin erneut verschiebt. Ebenfalls
geplant ist ein Start im US-Markt, welches mit Meizu erfolgen soll. Auch hierzu
wollte man sich nicht näher festlegen. Geplant sei aber wohl eine Veröffentlichung
mit dem Partner Meizu in der Mitte dieses Jahres.&lt;/p&gt;
&lt;h3 id=&#34;der-tag-danach&#34;&gt;Der Tag danach&lt;/h3&gt;
&lt;p&gt;Der Tag nach dem Event war vollständig losgelöst vom Launch Event, sodass jeder
machen konnte was er möchte. Während man beim Frühstück noch einige Leute
traf, verteilte sich die Gruppe komplett. Ich selbst war mit &lt;a href=&#34;https://plus.google.com/u/0/+JordanKeyes/&#34;&gt;Jordan Keyes&lt;/a&gt;
in der Innenstadt von London unterwegs. wo wir vorallem auch das bq Ubuntu Phone
unter Realbedingungen getestet haben.&lt;/p&gt;
&lt;p&gt;Am Abend saßen dann &lt;a href=&#34;https://plus.google.com/u/0/+JonoBaconProfile&#34;&gt;Jono Bacon&lt;/a&gt;,
&lt;a href=&#34;https://plus.google.com/u/0/+StuartLangridge&#34;&gt;Stuart Langridge&lt;/a&gt;, &lt;a href=&#34;https://plus.google.com/u/0/+JordanKeyes/posts&#34;&gt;Jordan Keyes&lt;/a&gt;
und ich zusammen. Was da geschah lasse ich lieber mal unkommentiert, man kann es allerdings
sehr gut an den Posts in den diversen Google+-Profilen entnehmen. ;)&lt;/p&gt;
&lt;p&gt;Spätestens am Sonntag verließen die letzten London in Richtung Heimat.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Das Event war toll! Viel wichtiger für mich als das Smartphone selbst, war für
mich das Kennenlernen vieler neuer Leute die sich in der Ubuntu-Community
einbringen. Ich möchte mich an dieser Stelle ebenfalls bei Canonical für die
Einladung für das Event bedanken. Leider war viel zu wenig Zeit um sich mit allen
Leuten ausführlich zu unterhalten, aber dagegen kann man wohl eher nicht viel machen.
Ein paar weitere Bilder von der Veranstaltung habe ich auf meinem &lt;a href=&#34;https://plus.google.com/u/0/+SujeevanVijayakumaran/posts/HvJZwV6TC9U&#34;&gt;Google+-Profil veröffentlicht&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Ich selbst habe jetzt noch einige Arbeit bezüglich des Smartphones vor mir. Insbesondere
eines ausführlichen Tests des Smartphones. Stay tuned!&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Labdoo Laptop-Spende an eine Schule in Sri Lanka</title>
      <link>https://svij.org/blog/2015/02/05/labdoo-srilanka/</link>
      <pubDate>Thu, 05 Feb 2015 20:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/05/labdoo-srilanka/</guid>
      <description>&lt;p&gt;Labdoo ist ein weltweit organisiertes Projekt um bereits genutzte und nicht mehr
gebrauchte Laptops an Bildungseinrichtungen in Entwicklungsländer zu bringen,
wo sie dann von Schülern genutzt werden können.&lt;/p&gt;
&lt;h3 id=&#34;labdoo&#34;&gt;Labdoo&lt;/h3&gt;
&lt;p&gt;Jedes Jahr werden vor allem in den Industrieländern sehr viele Laptops gekauft.
Nach und nach liegen viele Laptops, die nicht mehr genutzt werden, in der Ecke
rum und verstauben. Währenddessen gibt es zahlreiche Länder in denen viele
jungen Menschen der Zugang zu Computern und dem Internet für Bildungszwecke fehlt.&lt;/p&gt;
&lt;p&gt;Labdoo setzt sich dafür ein, dass genau diese Laptops, die in den Industrieländern
schon ausgedient haben, zu Bildungseinrichtungen in Entwicklungsländern gebracht
werden. Die Laptops werden zunächst in sogenannten „Hubs“ weltweit eingesammelt.
Dort werden sie dann aufbereitet. Darunter fällt unter anderem der Austausch
von möglichen defekten Teilen und das Aufspielen von Edubuntu mit zahlreichen
Software-Paketen die für die Schüler nützlich sind, etwa einem Offline-Wiki
und Lern-Software.&lt;/p&gt;
&lt;p&gt;Im dritten Schritt folgt die Übergabe der Laptops an die Schule. Dies wird, wie
auch die anderen Aufgaben, von freiwilligen Mitarbeitern übernommen. Menschen,
die um die Welt reisen, können sich bei Labdoo registrieren um Laptops an eine
Schule zu bringen. Die Kosten für den Transport trägt die jeweils reisende
Person. Meistens wird allerdings sowieso das zur verfügungstehende Gepäck genutzt,
um die Laptops zu transportieren. Wichtig im Labdoo-Projekt ist auch, dass der
Transport möglichst umweltfreundlich abläuft. Daher wird bevorzugt, den Platz
im Koffer zu nutzen, statt ein Paket abzuschicken. Darüber hinaus sieht man bei der
persönlichen Übergabe der Laptops noch viele fröhliche Kinder.&lt;/p&gt;
&lt;p&gt;Es können eine Vielzahl an Laptops gespendet werden. Geeignet sind Laptops ab
dem Baujahr 2001 (Pentium 4), eBook Reader, Tablet-PCs und auch solche Geräte,
die noch funktionsfähig sind, aber eine Entsorgung zu schade wäre.&lt;/p&gt;
&lt;p&gt;Neben den vollständigen Geräten werden auch Ersatzteile gebraucht, wie Arbeitsspeicher
in jeglicher Variante (für Laptops), Laptop-Festplatten, Tastaturen und Mäuse, Netzwerk-Geräte
oder auch Ladegeräte für Laptops und Taschen.&lt;/p&gt;
&lt;p&gt;Die Laptops oder andere Teile können an sogenannten „Labdoo Hubs“ abgegeben werden,
wo die Laptops dann weiter aufbereitet werden und anschließend an die Schulen gehen.
Eine Liste der Hubs in Deutschland findet sich &lt;a href=&#34;http://www.labdoo.org/de/hubs?country=de&#34;&gt;auf der Labdoo-Webseite&lt;/a&gt;.
Besonders im Rhein-Ruhr-Bereich in Nordrhein-Westfalen sind viele Hubs vorhanden.
Jeder Spender bekommt regelmäßig Status-Akualisierungen, damit jeder Spender
Bescheid weiß, in welchem Status sich der Laptop gerade befindet. Der Spender
bekommt mit, wenn der Laptop fertig eingerichtet ist, auf dem Weg zur Schule ist,
oder auch, wenn es final an einer Schule angekommen ist. Auf der Webseite sind
dann Fotos zu sehen, wie die Laptops an der Schule übergeben worden sind und wie
sie im Einsatz ist. Der Spender kann daher sicher gehen, dass der Laptop auch
dort angekommen ist, wo es hinsollte.&lt;/p&gt;
&lt;h3 id=&#34;mein-labdoo-zyklus&#34;&gt;Mein Labdoo-Zyklus&lt;/h3&gt;
&lt;p&gt;Ich selbst habe zum ersten Mal im Jahr 2012 in einem &lt;a href=&#34;http://ikhaya.ubuntuusers.de/2012/02/01/hilfsprojekt-www-labdoo-org-hilft-elektroschrott-zu-vermeiden-alte-laptops-fuer-schulen-in-entwi/&#34;&gt;Ikhaya-Artikel&lt;/a&gt;
vom Projekt Labdoo gelesen. Im November 2013 und 2014 habe ich dann nochmal
jeweils mit Ralf Hamm vom Labdoo-Projekt auf der OpenRheinRuhr in Oberhausen
gesprochen. Ralf mat mich dort dann direkt motiviert, doch auch mitzuhelfen.
Da meine Eltern aus Sri Lanka stammen und für uns sowieso im Januar 2015 eine
Reise nach Sri Lanka anstand, war die Situation natürlich ideal. Ich selbst habe
den Weg gewählt, möglichst alles selbst zu erledigen.&lt;/p&gt;
&lt;h4 id=&#34;schritt-1-laptops-beschaffen&#34;&gt;Schritt 1: Laptops beschaffen&lt;/h4&gt;
&lt;p&gt;Zunächst mussten also Laptops beschafft werden. Dies war zum Glück die leichteste
Aufgabe, da sowohl in meinem Büro als auch im Büro meines Arbeitskollegen
jeweils ein alter Arbeits-Laptop stand, die nicht mehr in Benutzung waren. Eine
kurze Anfrage beim Arbeitgeber hat gereicht, damit diese Laptops gespendet
werden dürfen, was ohne Probleme akzeptiert wurde. Mein Arbeitgeber, die &lt;a href=&#34;http://www.otris.de/otris/de/home.jhtml&#34;&gt;otris software AG&lt;/a&gt;
hat somit zwei ausgediente Laptops zur Verfügung gestellt. Im Gegenzug werden
Firmen auf der &lt;a href=&#34;http://www.labdoo.org/de/content/spender&#34;&gt;Spenden-Seite bei Labdoo&lt;/a&gt; genannt.&lt;/p&gt;
&lt;h4 id=&#34;schritt-2-schule-finden&#34;&gt;Schritt 2: Schule finden&lt;/h4&gt;
&lt;p&gt;Das Finden einer geeigneten Schule war interessanterweise das Schwierigste des
ganzen Projektes. In Sri Lanka sind einige Schulen in den größeren Städten meistens
schon mit Computern ausgestattet, da die Regierung dafür Mittel zur Verfügung
stellt. Bei diesem Schritt bekam ich Hilfe von meiner Mutter, welche die Idee
vom Projekt ebenfalls gut findet und mich dabei unterstützte. Nach einigen Wochen
herumtelefonieren fand meine Mutter schließlich über eine frühere Lehrerin den
Kontakt zur Schule und dessen Schulleiter.&lt;/p&gt;
&lt;p&gt;Die Schule liegt abseits von den Großstädten, etwa 100 km Luftlinie der Stadt
Jaffna im Norden Sri Lankas. Die Schule „Thadchanamaruthamadhu G.T.M.S“ liegt
in der Kleinstadt Madhu. Die selbe Stadt wurde etwa eine Woche vor meinem Besuch
von Papst Franziskus besucht.&lt;/p&gt;
&lt;h4 id=&#34;schritt-3-laptops-aufbereiten&#34;&gt;Schritt 3: Laptops aufbereiten&lt;/h4&gt;
&lt;p&gt;Da beide Laptops sich in einem guten Zustand befanden, musste lediglich das System
aufgespielt werden. Die Installation verläuft Image-basiert, welches im &lt;a href=&#34;http://www.labdoo.org/de/node/1725#FAQ03&#34;&gt;FAQ von Labdoo&lt;/a&gt;
beschrieben ist. Konkret wird ein Edubuntu-System aufgespielt, in dem einige
Software-Pakete für Bildungszwecke vorinstalliert ist.&lt;/p&gt;
&lt;h4 id=&#34;schritt-4-transport-ins-zielland&#34;&gt;Schritt 4: Transport ins Zielland&lt;/h4&gt;
&lt;p&gt;Im vierten Schritt folgte der Transport in das Zielland Sri Lanka. Sicher verpackt
im Reisegepäck zwischen der eigenen Kleidung. Bei einer Reise von drei Personen
und 90 kg Reisegepäck nehmen zwei ältere Laptops inklusive Docking-Station schon
fast 8 kg ein.&lt;/p&gt;
&lt;h4 id=&#34;schritt-5-transport-zur-schule&#34;&gt;Schritt 5: Transport zur Schule&lt;/h4&gt;
&lt;p&gt;Der Transport zur Schule inklusive An- und Abfahrt nahm insgesamt an die 12 Stunden
in Anspruch. Früh morgens um 7 Uhr ging es auf dem Weg von Jaffna in die Stadt
Madhu. Mit einigen Umwegen und einigen Besichtigungen auf dem Weg, kamen wir
schließlich zur Mittagszeit an der Schule an. Der Weg dorthin war lang und steinig. Viele Straßen
in der Nähe der Schule hatten keinen festen Belag oder waren übersäht von Schlaglöchern.
Rund um die Schule sind fast keine Häuser zu sehen. Man könnte schon sagen, dass
die Schule „mitten im nirgendwo“ liegt. Auch die Schüler haben somit einen weiten
Weg zur Schule.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/labdoo_way_to_school.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Der Weg zur Schule war übersäht mit Schlaglöchern.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/labdoo_way_to_school.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Angekommen an der Schule, wurden wir zunächst vom Schulleiter begrüßt.
Nach einer kurzen Vorstellung folgte dann die Übergabe der Laptops. Die Schule hat,
zu meiner Überraschung, sich sehr viel Mühe gegeben. Zunächst folgte einer Versammlung
der ganzen Schule auf dem Hof. Dies umfasste knapp 300 Schüler und Schülerinnen
sowie etwa 20 Lehrkräfte. Dort folgte zunächst eine Dankensrede von einem Lehrer
sowie des Schulleiters. In der Rede bedankten sich beide Personen bei uns, für
die Übergabe der Laptops. Kurz danach sollten auch wir ein Wort an die Schüler
richten. Auf Grund meiner eher mittelmäßigen tamilischen Sprachkenntnisse ist
zum Glück mein Vater eingesprungen und hat ein paar Worte an die Schüler gerichtet.
Die Schüler bedankten sich dann mit einem „Thank you, Sir“ im Chor.
Anschließend folgte noch die Einweisung in die Nutzung der Laptops an einen
Science-Lehrer durch mich.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/labdoo_meetup.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Versammlung.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/labdoo_meetup.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;a href=&#34;https://svij.org/graphics/labdoo_handover.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Übergabe der Laptops durch meiner Schwester und mir.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/labdoo_handover.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;a href=&#34;https://svij.org/graphics/labdoo_pupils.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die Schüler.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/labdoo_pupils.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;a href=&#34;https://svij.org/graphics/labdoo_classroom.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Der Klassenraum ist eher bedürftig eingerichtet.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/labdoo_classroom.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;a href=&#34;https://svij.org/graphics/labdoo_using.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die Schüler nutzen den Laptop.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/labdoo_using.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Die Spende der Laptops inklusive des Vorbeibringen der Laptops an der Schule
war sehr interessant. Ich kann nur jeden dazu ermutigen, ebenfalls zu helfen.
Jeder der einen alten, nicht mehr genutzten Laptop zur Verfügung hat, sollte
sich Gedanken machen, ob man diesen nicht spendet. Gegenüber anderen Projekten wie
„One Laptop per Child“ liegt hier die Besonderheit, dass nicht extra Hardware
produziert werden muss, sondern bereits ausgediente Laptops wiederverwendet werden.
Der Transport verläuft dabei grundsätzlich unter geringem finanziellen Aufwand.
Es ist ebenfalls toll zu sehen, wie sich die Schule und die Schüler freuen, wenn
sie Laptops bekommen. Wichtig ist zudem, dass möglichst viele von dieser Möglichkeit
der Spende wissen. Das umfasst nicht nur technik-affine Personen, sondern
auch „normale“ Personen, die alte Laptops ungebraucht zuhause liegen haben.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Ubuntu Phone Insider Event in London am 6. Februar</title>
      <link>https://svij.org/blog/2015/02/05/ubuntu-phone-insider-event-in-london-am-6-februar/</link>
      <pubDate>Thu, 05 Feb 2015 12:25:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/02/05/ubuntu-phone-insider-event-in-london-am-6-februar/</guid>
      <description>&lt;p&gt;Für &lt;a href=&#34;http://ikhaya.ubuntuusers.de&#34;&gt;Ikhaya&lt;/a&gt; habe ich bereits im Dezember über
&lt;a href=&#34;http://ubuntuusers.de/ikhaya/6443/&#34;&gt;den Launch vom ersten Ubuntu Phone&lt;/a&gt; geschrieben.
Am morgigen 6. Februar findet dazu in London das sogenannte „Ubuntu Phone Insider
Event“ statt. Dort wird dann das erste Ubuntu Phone, welches von der spanischen
Firma bq gefertig wird, vorgestellt. Mit dabei sind nicht nur Mitarbeiter von
Canonical, sondern es sind auch viele Leute aus der Community eingeladen. Darunter
bin glücklichweise auch ich, sodass ich als wohl einziger Deutscher aus der
deutschen Community dort anwesend sein werde. Schön ist auch, dass
jedes eingeladene Community-Mitglied das Phone noch vor offiziellen Marktstart
geschenkt bekommt.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/ubuntuphone_event.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Event-Einladung&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/ubuntuphone_event.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Vor Ort versuche ich dann morgen noch ein paar nette Interviews zu führen, solange
es die Zeit und die Möglichkeit dazu gibt mit den passenden Leuten zu reden.
Immerhin hat &lt;a href=&#34;https://twitter.com/jonobacon/status/562670491547090944&#34;&gt;Jono Bacon über Twitter&lt;/a&gt;
einem Interview zugestimmt ;-). Falls jemand Fragen über Ubuntu Phone hat, die
nicht ganz offensichtlich im Internet stehen, dann kann man sie mir gerne mailen
(an &lt;a href=&#34;mailto:svij@ubuntu.com&#34;&gt;svij@ubuntu.com&lt;/a&gt;). Ich versuche dann möglichst viel abzudecken.&lt;/p&gt;
&lt;p&gt;Testbericht vom Phone, Geschehnisse vom Launch Event und weiteres über Ubuntu
Phone folgen dann sowohl hier als auch auf &lt;a href=&#34;http://ikhaya.ubuntuusers.de&#34;&gt;ikhaya.ubuntuusers.de&lt;/a&gt;.
Zwischendurch werde ich morgen wohl auch über mein &lt;a href=&#34;https://plus.google.com/u/0/+SujeevanVijayakumaran&#34;&gt;Google+-Profil&lt;/a&gt;
und über &lt;a href=&#34;https://twitter.com/svijee&#34;&gt;Twitter&lt;/a&gt; vom Event berichten.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git für Einsteiger - Teil 3</title>
      <link>https://svij.org/blog/2015/01/12/git-fur-einsteiger-teil-3/</link>
      <pubDate>Mon, 12 Jan 2015 19:35:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/01/12/git-fur-einsteiger-teil-3/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://svij.org/blog/2014/11/01/git-fur-einsteiger-teil-2/&#34;&gt;Im zweiten Teil des Git Tutoriums&lt;/a&gt; wurde ein Überblick über das Branching-Modell gegeben.
Dieser dritte Teil rundet den Einstieg in Git ab, womit man für die gängigsten Aufgaben gewappnet
sein sollte. Dies umfasst zum einen das Rebasing und zum anderen das Arbeiten mit Remote-Repositorys.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Dieses Tutorium besteht aus vier Teilen. Wem das Tutorium gefällt und mehr über
Git lernen möchte, der kann sich das Buch &lt;a href=&#34;https://amzn.to/3q0A5Iu&#34;&gt;„Versionsverwaltung mit Git“&lt;/a&gt;
für 29,99€ bestellen. In diesem Buch, was ich geschrieben habe, werden die Themen rund um Git noch
deutlich ausführlicher behandelt.&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;rebasing&#34;&gt;Rebasing&lt;/h3&gt;
&lt;p&gt;Das Rebasing gehört ebenfalls zum Branching-Modell von Git. Im vorherigen Teil des Tutoriums
wurde Branches mit dem &amp;ldquo;git merge&amp;rdquo; Befehl zusammen geführt. Eine andere Art der Zusammenführung
von Branches ist das Rebasing.&lt;/p&gt;
&lt;p&gt;Beim normalen Mergen werden beide Branches zusammen geführt und gegebenenfalls ein Merge-Commit
erzeugt. Anders sieht es beim Rebasing aus. In diesem Fall werden die Commits aus einem Branch
einzeln auf dem Haupt-Branch angewendet. Ein Unterschied zum normalen Merge ist, dass in der
Historie des Repositorys beziehungsweise des Branches keine der vorherigen angelegten Branches mehr
sichtbar sind.&lt;/p&gt;
&lt;p&gt;Um die Funktionsweise besser zu erläutern und zu verstehen, folgt das erste Beispiel, wofür
wieder jeweils ein Commit auf zwei Branches gebraucht werden. Zunächst
muss man sicherstellen, dass man auf dem Branch &amp;ldquo;master&amp;rdquo; befindet, von dem man dann den zweiten
Branch namens &amp;ldquo;more_content&amp;rdquo; anlegt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout master
$ git checkout -b more_content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Auf diesen Branch muss man nun in der Datei &amp;ldquo;index.html&amp;rdquo; ein wenig mehr Inhalt hinzufügen. Dazu reicht es etwa den Lorem-Ipsum
Text in den &amp;ldquo;&amp;lt;p&amp;gt;&amp;quot;-Tag zu verdreifachen. Die Änderung kann dann wieder wie gewohnt commitet werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Verdreifachung des Lorem-Ipsum-Texts&amp;quot;
[more_content 609f8a4] Verdreifachung des Lorem-Ipsum-Texts
1 file changed, 6 insertions(+)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Einen Commit auf dem Branch &amp;ldquo;more_content&amp;rdquo; gibt es an dieser Stelle somit auch schon. Jetzt muss man zunächst
mit dem Befehl &amp;ldquo;git checkout master&amp;rdquo; wieder zurück auf den Branch &amp;ldquo;master&amp;rdquo; wechseln und dort einen Commit erzeugen.&lt;/p&gt;
&lt;p&gt;In der index.html kann man nun für den ersten Commit in der Navigation folgende Zeile verdreifachen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;li&amp;gt;&amp;lt;a href=&amp;quot;#&amp;quot;&amp;gt;Link&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann man den ersten Commit tätigen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Navigation um zwei Links erweitert.&amp;quot;
[master 8d8d6ce] Navigation um zwei Links erweitert.
1 file changed, 2 insertions(+)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Im zweiten Teil dieser Artikel-Reihe hätten wir an dieser Stelle einen Merge gemacht.
Konkret würde bei einem &amp;ldquo;git merge more_content&amp;rdquo; der eine Commit aus dem Branch &amp;ldquo;more_content&amp;rdquo;
in den Branch &amp;ldquo;master&amp;rdquo; gemergt und es würde zusätzlich ein weiterer Merge-Commit entstehen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git3_merge.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;So sähe die Zusammenführung der Branches bei einem normalen Merge aus.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git3_merge.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Den Merge-Commit möchte man beim Rebasen allerdings vermeiden. Ziel des Rebasing ist es,
das man den ursprünglichen Entwicklungsbranch nicht mehr sieht und es dann aussieht wie
ein gerader Entwicklungs-Strang. Hier stellt sich natürlich die Frage, was jetzt die genauen Vorteile
und auch Nachteile vom Rebasen gegenüber dem Mergen ist. Wie bereits oben im Text erwähnt,
werden die Commits einzeln auf dem Branch neu angewendet. Die genaue Funktion wird klarer,
wenn man es einmal durchgeführt hat. Hierfür wechselt man zunächst zurück auf den Branch
&amp;ldquo;more_content&amp;rdquo; und macht dort den Rebase.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout more_content
$ git rebase master
Zunächst wird der Branch zurückgespult, um Ihre Änderungen
darauf neu anzuwenden...
Wende an: Verdreifachung des Lorem-Ipsum-Texts
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man also auf dem Branch &amp;ldquo;more_content&amp;rdquo; ist und die Änderungen aus dem Branch &amp;ldquo;master&amp;rdquo;
übernehmen möchte ohne einen Merge-Commit zu haben, dann muss man &amp;ldquo;git rebase master&amp;rdquo; ausführen.
Wie man aus der Terminal-Ausgabe ablesen kann, wird der Branch zunächst &amp;ldquo;zurückgespult&amp;rdquo;, das heißt,
dass in diesem Schritt vorübergehen die gemachten Änderungen vorübergehend zurück genommen werden. Anschließend
übernimmt Git die Commits aus dem anderen Branch, in diesem Fall aus dem Branch &amp;ldquo;master&amp;rdquo;. Zum Schluss
werden die Commits vom Branch einzeln wieder angewandt. Da es sich in diesem Beispiel um lediglich
einen Commit handelt, wird auch nur dieser angewandt.&lt;/p&gt;
&lt;p&gt;Klarer wird es, wenn man sich die Commits auf einem Branch als einen Stapel vorstellt. Beim Rebase
wird auf &amp;ldquo;more_content&amp;rdquo; sozusagen jeder Commit vom Stapel genommen, bis es einen gemeinsamen
Commit vom Branch &amp;ldquo;master&amp;rdquo; gefunden hat. An diesem Punkt werden dann die neuen Commits von &amp;ldquo;master&amp;rdquo;
wieder auf &amp;ldquo;more_content&amp;rdquo; gestapelt. Anschließend werden die vorläufig entfernten Commits auf &amp;ldquo;more_content&amp;rdquo;
wieder einzeln auf den Commit-Stapel gelegt.&lt;/p&gt;
&lt;p&gt;Jetzt lohnt sich ein Blick in das Log. Relevant sind lediglich die letzten drei Commits, weshalb
man mit dem Parameter &amp;ldquo;-n 3&amp;rdquo; auch ausschließlich die drei neuesten Commits auf dem aktuellen
Branch anschauen kann.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git log -n 3
commit 27bf2ae348279599cfa67fd0631e7f3e5c90840d
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Sun Jan 4 19:03:23 2015 +0100

Verdreifachung des Lorem-Ipsum-Texts

commit 8d8d6ce271ddf776def806bbe65c1439c84f8c67
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Sun Jan 4 19:12:42 2015 +0100

Navigation um zwei Links erweitert.

commit aa2fbe6716f743d434a0f7bec9b97548304338c8
Merge: b967fa1 b6781c8
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Sun Jan 4 15:54:15 2015 +0100

Merge branch &#39;titel&#39;

Conflicts:
    index.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Im Git Log steht oben immer der neueste Commit auf dem Branch. Wer jetzt allerdings genau hinsieht,
der merkt, dass der oberste Commit um 19:03 Uhr getätigt wurde und der Commit darunter um 19:12 Uhr. Zeitlich
betrachtet ist also der vorletzte Commit der neueste Commit, während der echte neueste Commit zeitlich
vorher erzeugt wurde. Dies ist eine Eigenschaft, die genau dann beim Rebasen zustande kommt. In der
Historie eines Git-Repositorys sind die Commits nämlich immer in logische Reihenfolge und diese ist
nicht zwangsläufig auch die zeitlich richtige Reihenfolge. Es stellt sich für viele vermutlich an dieser Stelle
die Frage: Warum brauche ich das?&lt;/p&gt;
&lt;p&gt;Beim Entwickeln von Software werden häufig einzelne Features gleichzeitig entwickelt. Wenn etwa der Branch
&amp;ldquo;master&amp;rdquo; nur vollständige und somit fertige Features enthält, dann werden dort immer nur die Änderungen
zusammengeführt, wenn die Branches fertig sind. Wenn man allerdings an einem größeren Feature entwickelt, welches
durchaus längere Zeit braucht, dann zweigt man beispielsweise vom Branch &amp;ldquo;master&amp;rdquo; ab und entwickelt für eine Zeit
dort sein Feature. Über die Zeit hinweg läuft allerdings auch die Entwicklung auf dem Branch &amp;ldquo;master&amp;rdquo;
weiter, was heißt, dass diese beidem Entwicklungszweige gegebenenfalls immer stärker divergieren. Ein konflikt-freies
Mergen beider Branches nach längerer Entwicklungszeit ist dann gegebenenfalls nicht mehr so einfach möglich.
Wenn man dann auf dem Entwicklungsbranch ein Rebase durchführt, dann sind da auch alle Änderungen
von &amp;ldquo;master&amp;rdquo; enthalten. Dieses Vorgehen auch dann sinnvoll, wenn der Entwickler auf dem Entwicklungsbranch
die Änderungen aus &amp;ldquo;master&amp;rdquo; braucht. Unschön wäre hier ein Merge, da man in der Historie bei mehrmaligen
Mergen von &amp;ldquo;master&amp;rdquo; diverse Merge-Commits besitzt, die man durch das Rebasen einfach vermeiden kann.&lt;/p&gt;
&lt;p&gt;Nach dem Rebase möchte man die Änderungen vom Branch &amp;ldquo;more_content&amp;rdquo; letztendlich auch in &amp;ldquo;master&amp;rdquo;
übernehmen. Hierfür reicht dann wieder ein normaler Merge:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout master
$ git merge more_content 
Aktualisiere 8d8d6ce..27bf2ae
Fast-forward
index.html | 6 ++++++
1 file changed, 6 insertions(+)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Merge ist dann ein Fast-Forward Merge. Wenn man nun erneut in das Git Log von &amp;ldquo;master&amp;rdquo; schaut, dann
sieht man keinerlei Informationen mehr von der Existenz des Branches &amp;ldquo;more_content&amp;rdquo;. Rebasing lohnt sich also auch
für Experimentier-Branches, dessen Namen man hinterher nicht mehr in der Historie lesen möchte.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git3_merge2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Sowohl &#39;master&#39; als auch &#39;more_content&#39; sind nach dem Rebase und Merge identisch.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git3_merge2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Zum Schluss stellt sich noch die Frage, wann man Rebasen und wann man Mergen sollte. Als kleine Grundregel
kann man sich merken, dass man immer dann Rebasen sollte, wenn man zeitgleich laufende Änderungen regelmäßig
aus einem anderen Branch auch in seinem eigenen Entwicklungsbranch reinholen möchte. Ein Merge sollt man hingegen
dann tun, wenn man fertige Entwicklungsbranches in einen der Hauptentwicklungsbranches zusammenführen möchte.
Weder das eine noch das andere lässt sich problemlos jedes Mal durchführen, sodass es häufig auch auf die jeweilige
Situation ankommt, ob man nun rebased oder mergt.&lt;/p&gt;
&lt;h3 id=&#34;remote-repositorys&#34;&gt;Remote-Repositorys&lt;/h3&gt;
&lt;p&gt;Eine weitere große Stärke von Git ist, dass man ein Repository auf vielen verschiedenen
Rechnern verteilen kann. Es ist daher ein verteiltes Versionsverwaltungsprogramm.
Ein vollständiges Git-Repository kann an vielen verschiedenen Orten liegen.&lt;/p&gt;
&lt;p&gt;Diejenigen, welche das Git-Repository mit den zuvor
angegebenen Befehlen angelegt haben, besitzen zur Zeit nur ein lokales
Repository. Wichtig für das Verständnis ist, dass in der Theorie jedes Git-Repository
mit jedem gleichgestellt ist. In der Praxis sieht das allerdings etwas anders
aus, da bei den meisten Projekten mit einem zentralen Server gearbeitet wird.&lt;/p&gt;
&lt;p&gt;Entfernt liegende Repositorys nennt man Remote-Repositorys. Um mit eben diesen
zu arbeiten, gibt es den Befehl &amp;ldquo;git remote&amp;rdquo;. Wenn keine Remote-Repositorys
hinzugefügt worden sind, wie bei diesem Beispiel-Repository, dann erfolgt
keine Ausgabe beim Ausführen des Kommandos. Es bietet sich grundsätzlich
immer an, mit Remote-Repositorys zu arbeiten. Ein Projekt, dessen
Git-Repository nur auf einem lokalen Rechner liegt, ist kaum vor Ausfällen
gesichert. Remote-Repositorys sind insbesondere deshalb nützlich, da man damit
einfach kollaborativ arbeiten kann.&lt;/p&gt;
&lt;p&gt;Um die Arbeitsweise mit Remote-Repositorys zu verstehen und zu erlernen, werden
zunächst einige Remote-Repositorys angelegt, die auf dem lokalen Rechner liegen. In einem
Projekt mit mehreren Personen gibt es meist ein zentrales Repository für
das gesamte Projekt sowie einzelne Repositorys für die jeweiligen Projekt-Mitarbeiter.&lt;/p&gt;
&lt;p&gt;Man nehme also an, dass es in diesem Beispiel-Webseiten-Projekt zwei Mitarbeiter
gibt: &amp;ldquo;Ich&amp;rdquo; und &amp;ldquo;Er&amp;rdquo;. Dazu wechselt man erst in den
Projektordner &amp;ldquo;Webseite-mit-Git&amp;rdquo;, anschließend legt man die entsprechenden
Repositorys an:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ mkdir ~/Git
$ git clone --bare . ~/Git/Webseite-mit-Git.git
Klone in Bare-Repository &#39;/home/sujee/Git/Webseite-mit-Git.git&#39;...
Fertig.
$ git clone --bare . ~/Git/Er.git
Klone in Bare-Repository &#39;/home/sujee/Git/Er.git&#39;...
Fertig.
$ git clone --bare . ~/Git/Ich.git
Klone in Bare-Repository &#39;/home/sujee/Git/Ich.git&#39;...
Fertig.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl &amp;ldquo;git clone&amp;rdquo; klont, also kopiert, das ganze Repository. Es nimmt in diesem Fall
das aktuelle Projekt und speichert es dann in unter dem lokalen Pfad &amp;ldquo;~/Git/&amp;rdquo;. Der Inhalt
aller Ordner sind zu Beginn identisch und enthalten das &amp;ldquo;.git&amp;rdquo;-Verzeichnis des
Projekts.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Hinweis&lt;/em&gt;: Das oben erläuterte Anlegen von Repositorys ist keine alltägliche
Form, die einen in der Praxis erwartet. Dies dient lediglich dazu, das Arbeiten
mit Remote-Repositorys zu erläutern, was auch geht, wenn die Repositorys
lokal auf dem Rechner liegen. In der Regel setzt man eigene Git-Server-Dienste
auf oder nutzt externe Dienste wie &lt;a href=&#34;https://github.com&#34;&gt;GitHub&lt;/a&gt; oder &lt;a href=&#34;https://bitbucket.org/&#34;&gt;Bitbucket&lt;/a&gt;,
wo man sowohl private als auch öffentliche Repositorys anlegen kann. Auf eine genauere
Anleitung wird an dieser Stelle zunächst verzichtet, um den Rahmen des Tutoriums nicht zu
sprengen.&lt;/p&gt;
&lt;p&gt;Jetzt ist es an der Zeit die Remote-Repositorys mit dem Projekt zu verbinden.
Im Projekt-Ordner &amp;ldquo;Webseite-mit-Git&amp;rdquo; fügt man also zunächst sein privates
Repository als Remote hinzu.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote add origin ~/Git/ich.git
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dieses Kommando setzt sich aus mehreren Teilen zusammen. Der Parameter &amp;ldquo;remote&amp;rdquo;
bezieht sich auf Remote-Repository-Feature von Git. Mit &amp;ldquo;add&amp;rdquo; gibt man an,
das man ein Remote-Repository hinzufügen möchte. Der Parameter &amp;ldquo;add&amp;rdquo; verlangt
wiederum zwei Parameter, das wäre zum einen der Name und zum anderen der Pfad
zum Repository. Der Pfad zum entfernten Repository kann auch über SSH, HTTPS
oder über das Git-Protokoll erfolgen. Das eigene Repository wird in der
Regel &amp;ldquo;origin&amp;rdquo; genannt, dort sollte man auch volle Schreib-Rechte besitzen.&lt;/p&gt;
&lt;p&gt;Weiterhin bietet es sich nun an, die übrigen Remote-Repositories hinzuzufügen,
das wären &amp;ldquo;upstream&amp;rdquo; und &amp;ldquo;er&amp;rdquo;. Das Repository &amp;ldquo;upstream&amp;rdquo; soll das gemeinsame Repository
beider Mitarbeiter sein, auf dem die fertige Webseite kollaborativ erarbeitet
werden soll:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote add upstream ~/Git/Webseite-mit-Git.git
$ git remote add er ~/Git/Er.git
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl &amp;ldquo;git remote&amp;rdquo; sollte nun drei Remotes anzeigen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote
er
origin
upstream
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Bis jetzt wurde Git nur bekannt gegeben, dass es diese Remote-Repositorys gibt. Die Inhalte
wurden noch nicht in das lokale Repository heruntergeladen. Um dies zu erledigen,
gibt es das Git-Kommando &amp;ldquo;fetch&amp;rdquo;. Damit kann man die Bestandteile eines Remote-Repositorys
herunterladen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git fetch upstream
Von /home/sujee/Git/Webseite-mit-Git
* [neuer Branch]    content    -&amp;gt; upstream/content
* [neuer Branch]    master     -&amp;gt; upstream/master
* [neuer Branch]    menu       -&amp;gt; upstream/menu
* [neuer Branch]    more_content -&amp;gt; upstream/more_content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie man aus der Ausgabe herauslesen kann, wurde die Branches &amp;ldquo;master&amp;rdquo;, &amp;ldquo;content&amp;rdquo; und &amp;ldquo;menu&amp;rdquo;
und &amp;ldquo;more_content&amp;rdquo; vom Repository &amp;ldquo;upstream&amp;rdquo; heruntergeladen. Da es mühselig wäre,
für jedes Remote-Repository einzeln &amp;ldquo;git fetch&amp;rdquo; aufzurufen, gibt es auch eine Möglichkeit,
alle Remote-Repositories in einem Rutsch herunterzuladen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote update
Fordere an von upstream
Fordere an von er
Von /home/sujee/Git/Er
* [neuer Branch]    content    -&amp;gt; er/content
* [neuer Branch]    master     -&amp;gt; er/master
* [neuer Branch]    menu       -&amp;gt; er/menu
* [neuer Branch]    more_content -&amp;gt; er/more_content

Fordere an von origin
Von /home/sujee/Git/ich
* [neuer Branch]    content    -&amp;gt; origin/content
* [neuer Branch]    master     -&amp;gt; origin/master
* [neuer Branch]    menu       -&amp;gt; origin/menu
* [neuer Branch]    more_content -&amp;gt; origin/more_content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Alternativ kann man auch &amp;ldquo;git fetch &amp;ndash;all&amp;rdquo; ausführen, welches denselben Effekt hat.&lt;/p&gt;
&lt;p&gt;Die Remote-Repositories sind nun vollständig konfiguriert und liegen auch lokal im Projekt-Ordner.
Praktisch ist jetzt, dass man zwischen den einzelnen Branches der Repositories
wechseln kann.&lt;/p&gt;
&lt;p&gt;Mittlerweile wurden zwar einige Remote-Repositorys hinzugefügt, allerdings kann man durchaus
die vergebenen Namen nachschlagen. Es reicht lediglich folgenden Befehl auszuführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote
er
origin
upstream
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man eine ausführlichere Ausgabe möchte, etwa die Adresse des Remote-Repositorys, dann kann
man dem Befehl den Parameter &amp;ldquo;-v&amp;rdquo; übergeben.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote -v
er      /home/sujee/Git/Er.git (fetch)
er      /home/sujee/Git/Er.git (push)
origin  /home/sujee/Git/Ich.git (fetch)
origin  /home/sujee/Git/Ich.git (push)
upstream        /home/sujee/Git/Webseite-mit-Git.git (fetch)
upstream        /home/sujee/Git/Webseite-mit-Git.git (push)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Zum aktuellen Zeitpunkt ist sowohl das lokale als auch die entfernten Repositorys auf demselben Stand.&lt;/p&gt;
&lt;p&gt;Jetzt ist es notwendig, einen weiteren Commit zu tätigen. In diesem Beispiel nummeriert man einfach
alle Links in der Navigation aus der Datei &amp;ldquo;index.html&amp;rdquo;. Sodass man hinterher in der Navigation
nicht mehr 4x &amp;ldquo;Link&amp;rdquo; stehen hat, sondern &amp;ldquo;Link 1&amp;rdquo; bis &amp;ldquo;Link 4&amp;rdquo;. Anschließend erzeugt wieder einen Commit
mit dieser Änderung.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Links in der Navigation durchnummeriert.&amp;quot;
[master 59b89eb] Links in der Navigation durchnummeriert.
1 file changed, 4 insertions(+), 4 deletions(-)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Jetzt ist zwar ein Commit angelegt worden, diesen möchte man allerdings noch in das entfernt liegende Repository
pushen. Dies ist ein gängiges Prozedere, um die Änderungen online zu bringen, etwa um mit anderen zu kollaborieren
oder um seine Arbeiten zu sichern.&lt;/p&gt;
&lt;p&gt;Jetzt könnte man direkt den Push-Befehl ausführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git push
fatal: Der aktuelle Branch master hat keinen Upstream-Branch.
Um den aktuellen Branch zu versenden und den Remote-Branch
als Upstream-Branch zu setzen, benutzen Sie

git push --set-upstream origin master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man &amp;ldquo;git push&amp;rdquo; ohne jeglichen Parameter ausführt, dann versucht Git den aktuellen Branch auf das
Remote-Repository zu übertragen. Allerdings tut Git es nur, wenn ein Upstream-Branch gesetzt ist. Wie die
Aussage oben aussagt, muss man hierfür einen Upstream-Branch einrichten.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git push --set-upstream origin master
Zähle Objekte: 3, Fertig.
Delta compression using up to 4 threads.
Komprimiere Objekte: 100% (3/3), Fertig.
Schreibe Objekte: 100% (3/3), 408 bytes | 0 bytes/s, Fertig.
Total 3 (delta 1), reused 0 (delta 0)
To /home/sujee/Git/Ich.git
  27bf2ae..59b89eb  master -&amp;gt; master
Branch master konfiguriert zum Folgen von Remote-Branch master von origin.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Parameter &amp;ldquo;&amp;ndash;set-upstream&amp;rdquo; lässt sich ebenfalls in einer kürzeren Variante ausführen, dies ist dann
schlicht der Parameter &amp;ldquo;-u&amp;rdquo;.&lt;/p&gt;
&lt;p&gt;Der Befehl führt zwei Dinge aus: Zum einen pusht er der den Branch &amp;ldquo;master&amp;rdquo; zum Remote-Repository namens &amp;ldquo;origin&amp;rdquo; und zum anderen
verknüpft Git den lokalen Branch mit dem Remote-Branch auf origin.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git3_remote2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Sowohl &#39;master&#39; als auch &#39;origin/master&#39; haben einen Commit mehr als die übrigen Branches.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git3_remote2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Wenn man nun nur noch &amp;ldquo;git push&amp;rdquo; ausführt, dann wird automatisch der aktuelle lokale Branch &amp;ldquo;master&amp;rdquo; nach origin übertragen, sofern
Änderungen vorhanden sind.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git push origin master
Everything up-to-date.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Mittlerweile liegen im Repository vier Branches, wovon bereits alle Änderungen gemergt worden sind und keine mehr gebraucht werden.
Diese lassen sich ganz einfach mit dem folgenden Befehl löschen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git branch -d content
$ git branch -d menu more_content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Man kann das Löschen sowohl einzeln durchführen, oder auch gesammelt innerhalb eines Kommandos, wie es oben angegeben ist.
Übrig bleibt lediglich der Branch &amp;ldquo;master&amp;rdquo;. Wichtig zu wissen ist, dass hiermit ausschließlich die lokalen Branches gelöscht worden sind.
Wenn man nun auch noch auf dem Remote-Repository die Branches löschen möchte, muss man folgende Befehle ausführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git push origin --delete content
To /home/sujee/Git/Ich.git
- [deleted]         content
$ git push origin :menu
To /home/sujee/Git/Ich.git
- [deleted]         menu
$ git push origin --delete more_content
To /home/sujee/Git/Ich.git
- [deleted]         more_content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie man sieht, gibt es zwei verschiedene Möglichkeiten Remote-Branches zu löschen, das wäre zum einen das &amp;ldquo;git push&amp;rdquo; Kommando mit dem Paramater
&amp;ldquo;&amp;ndash;delete&amp;rdquo; und dem Namen des Remote-Branches und zum anderen kann man mit &amp;ldquo;git push&amp;rdquo; auch mit einem Doppelpunkt vor dem Branch-Namen den Remote-Branch
löschen. Klarer und deutlicher ist vorallem die erste Variante. Auch dieser Befehl lässt sich Zusammefassen, sodass man auch
einfach folgenden Befehl hätte ausführen können:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git push origin :menu :more_content :content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Praktisch ist auch der folgende Befehl:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote show origin
* Remote-Repository origin
  URL zum Abholen: /home/sujee/Git/Ich.git
  URL zum Versenden: /home/sujee/Git/Ich.git
  Hauptbranch: master
  Remote-Branch:
master gefolgt
  Lokaler Branch konfiguriert für &#39;git pull&#39;:
master führt mit Remote-Branch master zusammen
  Lokale Referenz konfiguriert für &#39;git push&#39;:
master versendet nach master (aktuell)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dieser zeigt alle relevanten Informationen von einem konfigurierten Remote-Repository an. Wenn man einen Namen
von einem Remote-Repository lokal ändern möchte, kann man auch folgenden Befehl ausführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote rename er jemand
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In diesem Fall wird dann der Name von &amp;ldquo;er&amp;rdquo; auf &amp;ldquo;jemand&amp;rdquo; geändert. Remote-Repositorys kann man auch einfach
wieder entfernen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git remote rm jemand
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl liefert im Erfolgsfall keine Ausgabe. An diesem Punkt ist wichtig zu wissen, dass nur die Verknüpfung
im lokalen Repository gelöscht wird. Auf dem entfernt liegenden
Server sind weiterhin die Daten vorhanden, sofern diese nicht schon vorher gelöscht worden sind.&lt;/p&gt;
&lt;p&gt;Zum Schluss muss man nur noch das korrekte Arbeiten mit Remote-Branches verstehen. Nach der vorangegangenen Aufräumaktion
sind noch zwei Remote-Repositorys übrig: origin und upstream. Auf origin befindet sich nur noch der Branch &amp;ldquo;master&amp;rdquo;,
auf upstream befinden sich noch alle vier Branches, wobei dort &amp;ldquo;master&amp;rdquo; noch nicht auf dem aktuellen Stand ist.&lt;/p&gt;
&lt;p&gt;Um &amp;ldquo;master&amp;rdquo; auch auf dem Remote-Repository namens &amp;ldquo;upstream&amp;rdquo; zu pushen, reicht folgender Befehl:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git push upstream
Zähle Objekte: 3, Fertig.
Delta compression using up to 4 threads.
Komprimiere Objekte: 100% (3/3), Fertig.
Schreibe Objekte: 100% (3/3), 408 bytes | 0 bytes/s, Fertig.
Total 3 (delta 1), reused 0 (delta 0)
To /home/sujee/Git/Webseite-mit-Git.git
  27bf2ae..59b89eb  master -&amp;gt; master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Da kein Branch-Name angegeben worden ist, wird der Branch gepusht, auf dem man sich gerade befindet.&lt;/p&gt;
&lt;p&gt;Jetzt steht nur noch an, dass man einen bestimmten Branch von &amp;ldquo;upstream&amp;rdquo; lokal ausschecken möchte. Die Remote-Branches
folgen einem Muster, nämlich &amp;ldquo;&lt;Remote&gt;/&lt;Branch-Name&gt;&amp;rdquo;. Wenn man also den Branch &amp;ldquo;content&amp;rdquo; ausschecken möchte, reicht
es folgenden Befehl auszuführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout upstream/content
Note: checking out &#39;upstream/content&#39;.

You are in &#39;detached HEAD&#39; state. You can look around, make experimental
changes and commit them, and you can discard any commits you make in this
state without impacting any branches by performing another checkout.

If you want to create a new branch to retain commits you create, you may
do so (now or later) by using -b with the checkout command again. Example:

  git checkout -b new_branch_name

HEAD ist jetzt bei e39da6e... Lorem-Ipsum Fülltext hinzugefügt.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Das Problem hier ist, dass man in einem anderen Zustand landet, der sich &amp;ldquo;detached HEAD&amp;rdquo; nennt.
Wie der Text schon aussagt, ist es ein Zustand, in dem man zwar Commits machen kann, allerdings
sind diese keinem Branch zugeordnet. Dies wird deutlich, wenn man &amp;ldquo;git branch&amp;rdquo; ausführt:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git branch
* (losgelöst von upstream/content)
  master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Zustand ist allerdings weniger problematisch, da man sich einfach einen neuen Branch anlegen kann,
basierend auf dem Branch upstream/content:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout -b content
Zu neuem Branch &#39;content&#39; gewechselt
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;So ist man nun wieder auf einen normalen Branch in einem normalen Zustand. Wenn man nun die Änderungen
von einem Remote-Branch auch lokal haben möchte, kann man diese mit &amp;ldquo;git pull&amp;rdquo; herunterladen. Der Pull-Befehl
ist das Gegenstück vom Push-Befehl.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git pull
There is no tracking information for the current branch.
Please specify which branch you want to merge with.
See git-pull(1) for details

git pull &amp;lt;remote&amp;gt; &amp;lt;branch&amp;gt;

If you wish to set tracking information for this branch you can do so with:

git branch --set-upstream-to=&amp;lt;remote&amp;gt;/&amp;lt;branch&amp;gt; content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie auch beim ersten Push-Befehl, fehlt dem lokalen Branch die Verknüpfung, woher die Änderungen
heruntergeladen werden sollen. Wenn man nur einmalig die Änderungen von upstream/content
holen möchte, reicht &amp;ldquo;git pull upstream content&amp;rdquo; auszuführen. Wenn man hingegen häufiger
aus demselben Branch vom selben Repository pullen möchte, dann bietet sich die oben aufgeführte
zweite Variante an.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;In diesem Teil der Artikel-Reihe zu Git wurden erläutert was das Rebasen ist, wie es geht und
warum man es nutzt. Weiterhin kann man jetzt mit Remote-Repositorys arbeiten und zwischen verschiedenen
Remote-Repositorys pullen und pushen.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/&#34;&gt;Hier geht es zu Teil 1&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2014/11/01/git-fur-einsteiger-teil-2/&#34;&gt;Hier geht es zu Teil 2&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Ubuntu 14.04 für Ein- und Umsteiger</title>
      <link>https://svij.org/blog/2015/01/11/rezension-ubuntu-1404-fur-ein-und-umsteiger/</link>
      <pubDate>Sun, 11 Jan 2015 15:15:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/01/11/rezension-ubuntu-1404-fur-ein-und-umsteiger/</guid>
      <description>&lt;p&gt;Das Buch „Ubuntu 14.04 - Für Ein- und Umsteiger“ ist ein Taschenbuch welches
sich speziell an Einsteiger und Umsteiger richtet. Es soll einen guten Einblick
in die tägliche Nutzung von Ubuntu geben.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Das Buch beinhaltet insgesamt 267 Seiten, die in 13 Kapiteln unterteilt sind.
Zusätzlich dazu beginnt das Buch mit einem einleitenden Vorwort. Das Buch
bietet einen Überblick über die Installation, Nutzung von Ubuntu und die Nutzung der
vorinstallierten Programmen. Dem Buch beigelegt ist ebenfalls eine Live-DVD von Ubuntu 14.04.&lt;/p&gt;
&lt;p&gt;Im einleitenden Kapitel geht es zunächst auf wenigen Seiten um die Frage,
was Linux bzw. Ubuntu ist und für wen es geeignet ist. Es wird dabei kurz
die Philosophie von Ubuntu erläutert, die existierenden Ubuntu-Derivate
aufgelistet, sowie Konzeption des Buches und der Inhalt der DVD beschrieben.&lt;/p&gt;
&lt;p&gt;Im ersten echten Kapitel wird zunächst erklärt, wie und wo man Ubuntu herunterladen
kann und wie man dazu das passende Boot-Medium, also DVD oder USB-Stick,
unter Windows erstellt.&lt;/p&gt;
&lt;p&gt;Das zweite Kapitel befasst sich mit der Live-Session von Ubuntu, welche man
mittels der beiliegenden DVD, der selbstgebrannten DVD oder mittels eines
USB-Sticks starten kann. Anschließend folgt eine Beschreibung, wie man die
gängigen Daten unter Windows sichern kann, um anschließend die Basis-Installation
durchzuführen, die im Anschluss daran erklärt wird.&lt;/p&gt;
&lt;p&gt;Im dritten Kapitel folgt der Einstieg in Unity, der grafischen Oberfläche von Ubuntu.
Dort wird ein guter Einstieg in die Komponenten des Unity-Desktops gegeben, etwa
wie der Launcher und die Dash funktioniert und was man alles im oberen Panel findet.&lt;/p&gt;
&lt;p&gt;Im Anschluss wird im vierten Kapitel dargelegt, wie man seine Ubuntu-Installation
einrichtet. Darunter fällt, wie man sich mit einem WLAN-Netzwerk verbindet und
was man zu tun hat, wenn etwa der WLAN-Stick nicht automatisch erkannt wird. Weiterhin
wird auch noch thematisiert, wie man einen UMTS-Stick in Betrieb nimmt. Neben dem
Internet-Zugang wird auch noch genannt, wie man das System aktualisiert, fehlende
Sprachpakete nachinstalliert und die Grafikkarte einrichtet. Zum Schluss des
Kapitels werden noch die Drucker- und Scanner-Einrichtung sowie die Installation von
Software aus dem Software-Center und auch außerhalb des Software-Centers beschrieben.&lt;/p&gt;
&lt;p&gt;Das fünfte Kapitel befasst sich mit der Nutzung von Firefox, Thunderbird, Empathy
und Skype. Mit dabei ist auch eine Anleitung, wie man seine Daten aus dem Firefox-
und Thunderbird-Profil aus dem Windows-System überträgt und in Ubuntu nutzbar
macht.&lt;/p&gt;
&lt;p&gt;Im sechsten Kapitel dreht es sich darum, wie man Windows-Programme unter Ubuntu
benutzt. Dabei wird nicht nur Wine genannt, sondern auch wie man sich mit VirtualBox
eine Windows-VM aufsetzen kann.&lt;/p&gt;
&lt;p&gt;Das siebte Kapitel widmet sich vom Einsatz von Ubuntu in einer Gruppe, also
die Erstellung und Verwaltung mehrere Benutzerkonten auf einem System.&lt;/p&gt;
&lt;p&gt;Anschließend folgt im achten Kapitel ein ausführlicher Überblick über LibreOffice.
Konkret wird mit vielen Screenshots bebildert die gängige Nutzung von Writer,
Calc, Impress und Draw beschrieben.&lt;/p&gt;
&lt;p&gt;„Mit Ubuntu in der Cloud“ lautet das Thema des neunten Kapitels. Hierbei geht es
grundsätzlich um verschiedene Cloud-Speicherdienste. So wird erklärt, wie man
Dropbox, Copy, Wuala und Spideroak unter Ubuntu installiert und einrichtet.&lt;/p&gt;
&lt;p&gt;Das zehnte Kapitel beleuchtet die Sicherheit des Systems. Allerdings ist die
Beschreibung zum Sicherheitskonzept eher kurz. Stattdessen ist eine Empfehlung
für sichere Passwörter enthalten und eine kurze Beschreibung wie man die Chronik
in Firefox deaktiviert. Weiterhin wird noch erläutert, wie man seine Dateien
mit dem Programm Déjà Dup sichert.&lt;/p&gt;
&lt;p&gt;Etwas in die Tiefe geht das elfte Kapitel, in dem die Verzeichnisstruktur von
Linux-Systemen erläutert wird. Außerdem folgt ein recht kurzer Einblick in die
Nutzung des Terminals.&lt;/p&gt;
&lt;p&gt;Das zwölfte Kapitel leitet das Ende des Buches ein, in dem die vorinstallierten
Programme in Ubuntu kurz beschrieben werden. Anschließend folgt das letzte Kapitel,
in dem erläutert wird, wie man eine VPN-Verbindung zu der heimischen Fritz!Box
einrichten kann.&lt;/p&gt;
&lt;h3 id=&#34;wie-liest-es-sich&#34;&gt;Wie liest es sich?&lt;/h3&gt;
&lt;p&gt;Wie es der Titel bereits beschreibt, eignet sich das Buch wirklich nur für
Einsteiger und Umsteiger. Insbesondere richtet sich das Buch auch an Einsteiger,
die bislang nur wenig einen Computer benutzt haben. Die Beschreibungen in dem
Buch sind in der Regel ausführlich, auch wenn nur auf die gängigsten Funktionen
eingegangen wird. Außerdem werden sehr viele Screenshots verwendet. Die Anleitungen
lassen sich dadurch sehr gut und einfach nachvollziehen. Das Buch ist in der
Ich-Perspektive geschrieben und enthält auch einige persönliche Meinungen des
Autors.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Das Buch ist der Nachfolger des Buches „Ubuntu 12.04 - Für Ein- und Umsteiger“,
welches in [freiesMagazin 10/2012](&lt;a href=&#34;http://www.freiesmagazin.de/freiesMagazin-2012-10&#34;&gt;http://www.freiesmagazin.de/freiesMagazin-2012-10&lt;/a&gt; freiesMagazin 10/2012)
rezensiert wurde. Es lohnt sich also ein Blick zurück zu werfen, um zu schauen,
ob die angebrachte Kritik umgesetzt wurde. Leider wurden damals schon eine Vielzahl
an Dingen bemängelt, die in dieser Ausgabe größtenteils wieder auftauchen.&lt;/p&gt;
&lt;p&gt;In der vorherigen Ausgabe des Buches war nicht bekannt, welche Kenntnisse und wie viel
Erfahrung der Autor im Umgang mit Ubuntu und Linux im Allgemeinen besitzt.
Das hat sich in dieser Ausgabe nicht geändert, da keinerlei Informationen zum
Autor dem Buch zu entnehmen ist.&lt;/p&gt;
&lt;p&gt;Ungünstig umgesetzt waren damals die Screenshots, da diese teilweise vom Bildschirm
abfotografiert wurden, schlecht angeschnitten wurden, sowie die Abbildungen
viel zu dunkel geraten sind. In dieser Ausgabe sind zwar eine Vielzahl an
abfotografierten Bildschirm-Abbildungen verschwunden, einige wenige sind allerdings
immer noch enthalten. Die Abbildungen sind teilweise immer noch zu dunkel, was
auch daran geschuldet ist, dass es gänzlich in Schwarz-Weiß gedruckt ist.
Schlecht und merkwürdig angeschnittene Screenshots sind allerdings weiterhin enthalten, sodass
man einige findet, in denen Teile der Titelleiste eines Fensters fehlen
oder einige Buchstaben im Nichts verschwinden. Ebenfalls fallen einige Screenshots
negativ auf, die im Vergleich zu anderen Screenshots deutlich verschwommener sind
als der Rest. Diese Fehler sind optische Feinheiten, die man sehr einfach hätte beheben können.&lt;/p&gt;
&lt;p&gt;Bereits im August 2011 wurde die [Hardwaredatenbank](&lt;a href=&#34;http://ubuntuusers.de/ikhaya/2292/&#34;&gt;http://ubuntuusers.de/ikhaya/2292/&lt;/a&gt; Hardwaredatenbank)
von ubuntuusers.de eingestellt, da sie nicht nur schlecht gewartet sondern auch
nicht sonderlich aktuell war. Obwohl dies bereits in der vorherigen Rezension
kritisiert wurde, fand auch dieser Teil den Weg in das Buch mit dem Zusatz,
dass die Hardwaredatenbank „aktuell und gut gepflegt“ ist.&lt;/p&gt;
&lt;p&gt;Gravierend sind außerdem die zahlreiche inhaltlichen Fehler, die sich in diesem
Buch finden. So wird diesmal wenigstens kurz erwähnt, dass es 32-Bit- und 64-Bit-Systeme
gibt und wie man prüfen kann, ob man ein 64-Bit-fähige Hardware vorhanden
ist. Allerdings wird auch diesmal empfohlen die 32-Bit-Variante zu nutzen, wenn
man sich nicht sicher ist. Skandalös ist allerdings die Aussage des Autors,
dass angeblich nicht alle Entwickler erkannt haben, dass sich die 64-Bit-Architektur
durchgesetzt hat. Dazu schreibt der Autor, dass Erfahrungen zeigen, dass die
32-Bit-Versionen angeblich stabiler und nahezu störungsfrei laufen, was bei
der 64-Bit-Version nicht der Fall sei, da sie mehr Probleme verursache. Dies führt
bei Unwissenden, an welche das Buch ja gerichtet ist, eher dazu, dass sie Angst
haben und die 32-Bit-Version installieren, obwohl die 64-Bit-Version sehr wohl
stabil ist.&lt;/p&gt;
&lt;p&gt;Wie bereits erwähnt, ist das Buch übersät von zahlreichen Fehlern. Unter anderem
heißt an einer Stelle der Desktop nicht mehr „Unity“ sondern „Utility“. Außerdem
wird auf die Downloadseite auf unbuntu.com verlinkt. Der Tippfehler führt interessanterweise
trotzdem auf die richtige Webseite auf ubuntu.com. An anderer Stelle wurde statt
auf ubuntuusers.de auf ububtuusers.de verlinkt, ebenfalls ein Tippfehler, der
eigentlich bei den Korrekturen auffallen hätte müssen. Ungünstig ist auch, dass ein
paar Befehle falsch aufgeführt werden, ein &amp;lsquo;&amp;lsquo;&amp;lsquo;Sudo&amp;rsquo;&amp;rsquo;&amp;rsquo; oder &amp;lsquo;&amp;lsquo;&amp;lsquo;Apt-get&amp;rsquo;&amp;rsquo;&amp;rsquo; mit beginnenden
Großbuchstaben führen nämlich zu einem Fehler. An andere Stelle wird zwar in der
Kapitelbeschreibung erwähnt, dass die Nutzung von Gwibber erklärt wird, zu finden
ist sie allerdings nicht. Interessant ist auch, dass bei der Anleitung zur
Installation von Grafikkarten-Treibern scheinbar ein Absatz oder gar eine ganze
Seite fehlt, da der Teil inhaltlich einfach keinen Sinn ergibt.&lt;/p&gt;
&lt;p&gt;Ebenfalls glänzt der Autor mit gefährlichen Halbwissen, so ist es angeblich
durch den Bug &lt;a href=&#34;http://heartbleed.com/&#34;&gt;Heartbleed&lt;/a&gt; möglich, den Quellcode
der „Sicherheitssoftware SSL“ anzugreifen. Außerdem bringt
der Autor zwar ein einigen Stellen Datenschutz ein, schreibt allerdings größtenteils
auch nur, dass man die Chronik der besuchten Webseiten im Firefox abschalten sollte und
Cookies nach dem Beenden von Firefox automatisch löschen lassen sollte. Wichtigere
Dinge wie etwa das Verhindern des Trackens von Webseiten-Besuchern mittels Plug-ins wie Ghostery oder Tor
werden in keinem Wort erwähnt.&lt;/p&gt;
&lt;p&gt;Inhaltlich fehlen meiner Meinung nach noch ein paar wichtige Dinge im Umgang
mit Ubuntu. Zwar wurde zwar wenigstens diesmal ganz kurz erwähnt, dass es andere
Derivate gibt, allerdings wäre da ein paar genauere Informationen schon sinnvoll
gewesen, da Ubuntu nicht nur Unity, sondern eben unter anderem auch Kubuntu, Xubuntu und
Lubuntu ist. Ein eigenes Kapitel wäre hierfür eher angebracht, als das Kapitel
zur Installation und Einrichtung eines VPN zur heimischen Fritz!Box. Dieses Kapitel
wird merkwürdigerweise mit Windows-Software angeleitet.&lt;/p&gt;
&lt;p&gt;Weiterhin fehlen jegliche Informationen zu den LTS- und STS-Versionen von Ubuntu.
So wird der Leser nicht schlau, wann er sein System aktualisieren sollte, wie
lang die Unterstützung für das System läuft und in welchen Rhythmus die LTS-Versionen
erscheinen. Weiterhin wäre es für Ein- und Umsteiger eher angebracht, mehr auf
äquivalenten Windows-Programme unter Linux einzugehen. Stattdessen wird ausführlich
auf Wine eingegangen und geschrieben, dass es mit einem großen Teil von nicht
allzu komplexen Windows-Programmen funktionieren soll. Sinnvoller wäre es daher,
nicht nur Firefox, Thunderbird und LibreOffice ausführlich zu erklären, sondern
auch etwa die Verwaltung von Fotos mit entsprechenden Programmen oder die Verwaltung
von Dateien mit Nautilus.&lt;/p&gt;
&lt;p&gt;Ebenfalls schwach ist, dass das Konzept der Paketverwaltung kaum zur Geltung kommt.
Es wird zwar erwähnt, dass man im Software-Center sehr viele Programme findet,
dazu fehlt allerdings die Information zur dahinter liegenden Paketverwaltung und
wie es mit den Aktualisierungen der Programme über die Aktualisierungsverwaltung
aussieht. Fatal ist auch, dass sowohl Skype als auch VirtualBox als Deb-Paket
über die Hersteller-Seite heruntergeladen werden, statt das Standard-Repository
beziehungsweise das Partner-Repository zu nutzen. Zwar wird einige Kapitel später
die Installation von Skype nochmals angeschnitten und das Canonical-Partner-Repository
erwähnt, allerdings erfolgte vorher die Installation des völlig veralteten Skype-Pakets
in Version 2.2. Hier scheint man einfach das Kapitel aus dem Vorgänger-Buch
ohne Korrekturen übernommen zu haben.&lt;/p&gt;
&lt;p&gt;Die Nutzung des Terminals wird zwar in dem Buch kurz angeschnitten, allerdings
nur sehr sehr oberflächlich und mit dem Zusatz, dass das Terminal ja nur
von Profis genutzt wird. Ein positiver Blick auf die sinnvollen Funktionen
eines Terminals fehlt völlig, stattdessen wird es als Tool für Profis negativ
abgestempelt.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Das Buch macht leider gar keinen guten Eindruck. Ein Großteil der
Anleitungen ist sehr gut auf Ein- und Umsteiger zugeschnitten, sodass diese schon
die Zielgruppe gut ansprechen. Nachteilig sind allerdings die zahlreichen optischen und
inhaltlichen Fehler, die schon ziemlich gravierend sind und womit der Autor seine
Unwissenheit zur Schau stellt. Für die meisten dürften sich daher das Buch
nicht sonderlich lohnen, da kann man die 15 Euro sinnvoller einsetzen. Der Autor selbst
verweist häufig auf das Wiki von ubuntuusers.de. Dort findet man nicht nur mehr Informationen,
diese enthalten in der Regel auch nicht solche gravierenden Fehler.&lt;/p&gt;
&lt;p&gt;Die &lt;a href=&#34;http://www.it-fachportal.de/media/vmi-buch/texte/download/7641_errata.pdf&#34;&gt;Errata zum Buch&lt;/a&gt;
gibt einen kleinen Einblick in das Geschriebene, wobei in der Errata immer noch
zahlreiche Fehler enthalten sind, die in dieser Rezension aufgeführt werden.&lt;/p&gt;
&lt;h4 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; Ubuntu 14.04 - Für Ein- und Umsteiger&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Christoph Troche&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt; bhv, 2014&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt; 267 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt; 978-3-8266-7641-3&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 14,99€&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Kollaborativ an LaTeX-Dokumenten arbeiten mit ShareLaTeX</title>
      <link>https://svij.org/blog/2015/01/11/kollaborativ-an-latex-dokumenten-arbeiten-mit-sharelatex/</link>
      <pubDate>Sun, 11 Jan 2015 13:45:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/01/11/kollaborativ-an-latex-dokumenten-arbeiten-mit-sharelatex/</guid>
      <description>&lt;p&gt;Die Web-Anwendung ShareLaTeX ermöglicht das kollaborative Arbeiten an LaTeX-Dokumenten
in einem Team. Die Oberfläche läuft vollständig im Browser und die Dokumente lassen sich
sowohl im Browser bearbeiten, kompilieren als auch anzeigen.&lt;/p&gt;
&lt;h3 id=&#34;allgemeines&#34;&gt;Allgemeines&lt;/h3&gt;
&lt;p&gt;ShareLaTeX begann ihren Dienst zunächst ausschließlich über ihre Webseite
&lt;a href=&#34;https://www.sharelatex.com/&#34;&gt;ShareLaTeX.com&lt;/a&gt; anzubieten. Es folgt dem „Freemium“
Prinzip, sodass man auf der Webseite zwar LaTeX-Projekte anlegen kann, diese
in der kostenfreien Variante allerdings an einigen Funktionen beschnitten ist.
Gegen Zahlung kann man sich hingegen ein Premium-Account mieten, in dem man
dann mehr Funktionen nutzen kann.&lt;/p&gt;
&lt;p&gt;Anfang 2014 stellten die Entwickler die Software von ShareLaTeX unter der AGPL v3
Lizenz, sodass man es auch auf seinen eigenen Server installieren kann. ShareLaTeX
ist in &lt;a href=&#34;https://de.wikipedia.org/wiki/CoffeeScript&#34;&gt;CoffeeScript&lt;/a&gt; geschrieben und
läuft auf &lt;a href=&#34;http://nodejs.org/&#34;&gt;node.js&lt;/a&gt;. Als Datenbank wird &lt;a href=&#34;https://de.wikipedia.org/wiki/Redis&#34;&gt;Redis&lt;/a&gt;
und &lt;a href=&#34;https://de.wikipedia.org/wiki/MongoDB&#34;&gt;MongoDB&lt;/a&gt; verwendet.&lt;/p&gt;
&lt;h3 id=&#34;installation-unter-ubuntu-1404&#34;&gt;Installation unter Ubuntu 14.04&lt;/h3&gt;
&lt;p&gt;Leider ist die Installation von ShareLaTeX auf dem eigenen Server nicht ganz
so einfach. Die Dokumentation im Wiki des &lt;a href=&#34;https://github.com/sharelatex/sharelatex/wiki&#34;&gt;ShareLaTeX-Repositorys&lt;/a&gt;
ist zum Beispiel nur die Installation mittels eines Deb-Pakets unter Ubuntu 12.04
oder die Installation unter ArchLinux beschrieben. Außerdem wird in der &lt;a href=&#34;https://github.com/sharelatex/sharelatex/wiki/Production-Installation-Instructions&#34;&gt;offiziellen&lt;/a&gt;
Installations-Anleitung die Installation von Fremd-Quellen vorgeschlagen, welches
man durchaus vermeiden kann.&lt;/p&gt;
&lt;p&gt;Voraussetzung für diese Installations-Anleitung ist ein System auf dem Ubuntu
14.04 läuft. Wichtig ist, dass der Server möglichst mindestens 1GB an Arbeitsspeicher
hat, sofern auf dem Server ausschließlich ShareLaTeX laufen soll. Die Installation
auf einem Server mit 512MB Arbeitsspeicher läuft zwar durch, allerdings kann es durchaus passieren,
dass man sich hinterher nicht mehr per SSH verbinden kann, da der Arbeitsspeicher
vollständig gefüllt ist.&lt;/p&gt;
&lt;p&gt;Zu Beginn muss man erst die Paket-Quellen aktualisieren und dann einige Pakete
installieren die benötigt werden, um die Installation durchzuführen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo apt-get update
$ sudo apt-get install git build-essential curl python-software-properties zlib1g-dev zip unzip ruby-dev
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Für den Produktiv-Betrieb werden, wie oben schon kurz erwähnt, node.js, redis
und mongodb benötigt&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo apt-get install nodejs npm redis-server mongodb
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;ShareLaTeX benötigt schließlich auch noch die LaTeX-Pakete. Diese können
entweder über die offizielle Anleitung der TeX Live Distribution(&lt;a href=&#34;https://www.tug.org/texlive/quickinstall.html&#34;&gt;https://www.tug.org/texlive/quickinstall.html&lt;/a&gt;)
erfolgen, alternativ kann man auch die TeX Live Pakete von Ubuntu installieren:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo apt-get install texlive latexmk texlive-lang-german texlive-latex-extra
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Sofern man weitere spezielle LaTeX-Pakete braucht, kann man diese natürlich je
nach Verwendungszweck problemlos nachinstallieren. Problematisch über die
Paket-Verwaltung könnte sich erweisen, dass ShareLaTeX das Paket latexmk
mindestens in der Version 4.39 benötigt. In den Paket-Quellen von Ubuntu ist
latexmk allerdings nur in Version 4.35 enthalten. Bei der Arbeit an nicht
allzu komplexen Dokumenten erwies sich dies im Nachhinein allerdings nicht als
ein Problem.&lt;/p&gt;
&lt;p&gt;Nichtsdestotrotz werden trotzdem einige externe Pakete benötigt, die mittels
npm und gem installiert werden müssen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo  npm install -g grunt-cli
$ gem install fpm
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend liegt Arbeitsverzeichnis ein &amp;ldquo;tmp&amp;rdquo;-Ordner, der problemlos gelöscht
werden darf. Danach muss man das Git-Repository clonen, zu Beachten ist, dass
man den Release-Branch nutzt und nicht den Master-Branch.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git clone -b release https://github.com/sharelatex/sharelatex.git
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Im Anschluss müssen einige Pakete über den Paketmanager von node.js npm installiert,
sowie letztendlich die ShareLaTeX-Dienste installiert werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ npm install
$ grunt install
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Beide Befehle dauern relativ lange, je nach verfügbaren Bandbreite dauert der
Download seine Zeit.&lt;/p&gt;
&lt;p&gt;Nachfolgend muss noch mit dem Tool grunt geprüft werden, ob alles erfolgreich
durchgelaufen ist:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ grunt check --force
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Parameter &amp;ldquo;&amp;ndash;force&amp;rdquo; ist notwendig, da grunt an dieser Stelle feststellt,
dass das latexmk Paket veraltet ist, sofern man es sich wie oben beschrieben
aus den Ubuntu Paketquellen installiert hat. Danach fehlt lediglich das
Bauen des Deb-Paketes. Allerdings muss hierfür die Datei &amp;ldquo;Gruntfile.coffee&amp;rdquo;
händisch angepasst werden. Konkret findet sich im Quellcode dieser Datei die
Zeile:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  &amp;quot;--depends&amp;quot;, &amp;quot;mongodb-org &amp;gt; 2.4.0&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dort muss &amp;ldquo;mongodb-org&amp;rdquo; durch &amp;ldquo;mongodb&amp;rdquo; ersetzt werden, da das Paket von mongodb
unter Ubuntu eben mongodb heißt und nicht mongodb-org. Die Zeile sollte im Anschluss
so aussehen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;  &amp;quot;--depends&amp;quot;, &amp;quot;mongodb &amp;gt; 2.4.0&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Jetzt kann das Deb-Paket mittels grunt gebaut werden und anschließend installiert
werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ grunt build:deb
$ sudo dpkg -i sharelatex_0.0.1_amd64.deb
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Nach der Installation ist ShareLaTeX lauffähig, und kann unter der IP des Servers bzw.
der Domain aufgerufen werden. Allerdings läuft es im Standard unter Port 3000. Man
muss daher http://IP_des_servers:3000 aufrufen, um auf die Web-Oberfläche von
ShareLaTeX zu gelangen. Um ShareLaTeX unter Port 80 und somit ohne Port-Angabe
im Browser erreichen zu können, kann man den Webserver nginx installieren, der
als Reverse-Proxy dient. Danach muss man lediglich das Laden der Standard-Konfigurationsdatei
von nginx unter &amp;ldquo;/etc/nginx/sites-enabled/default&amp;rdquo; unterbinden und nginx
die die Konfigurationsdateien neuladen lassen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ sudo apt-get install nginx
$ sudo rm /etc/nginx/sites-enabled/default
$ sudo service nginx reload
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;die-basis-einrichtung&#34;&gt;Die Basis-Einrichtung&lt;/h3&gt;
&lt;p&gt;Nach dem Abschluss der Installation kann man mit der Nutzung beginnen. Ein
normales Benutzerkonto kann man direkt erstellen ohne, dass man seine E-Mail
Adresse bestätigen muss. Wer jetzt allerdings eine Admininistrations-Oberfläche
sucht, der wird erstmal nicht fündig. Administrator-Rechte kann man lediglich
über die Datenbank vergeben. Dazu muss man folgendes in der Kommandozeile
ausführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ mongo
MongoDB shell version: 2.4.9
connecting to: test
&amp;gt; use sharelatex
switched to db sharelatex
&amp;gt; db.users.update((email:&amp;quot;mail@svij.org&amp;quot;), (&amp;quot;$set&amp;quot;:(isAdmin:true)))
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Im letzten Befehl muss da natürlich die eigene E-Mail Adresse angegeben werden,
um sich selbst die Rechte zu geben. Anschließend kann man unter http://IP_des_servers/admin
auf die Admin-Funktionen zugreifen.&lt;/p&gt;
&lt;p&gt;Außerdem kann man noch den Versand von E-Mails konfigurieren. Hierfür kann man
sich an die Anleitung von ShareLaTeX &lt;a href=&#34;https://github.com/sharelatex/sharelatex/wiki/Configuring-SMTP-Email&#34;&gt;selbst&lt;/a&gt;
halten.&lt;/p&gt;
&lt;h3 id=&#34;was-kann-es&#34;&gt;Was kann es?&lt;/h3&gt;
&lt;p&gt;Nachdem man sich ein Benutzerkonto erstellt und eingeloggt hat, bekommt man
eine Übersicht über seine angelegten Projekte. Zu Beginn sind da natürlich keine,
man kann sich allerdings sehr einfach ein Projekt anlegen. Man kann entweder
ein vollständig leeres Projekt angelegen, ein Beispiel-Projekt erstellen lassen
oder ein bereits existentes Projekt als Zip-Paket hochladen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/sharelatex_login.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Eine Übersicht über die angelegten Projekte.&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/sharelatex_login.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Wenn man nun ein Projekt angelegt hat, kann man dies öffnen und man sieht eine
drei geteilt Übersicht. Auf der linken Seite findet sich eine schmale Spalte
in welchem der Verzeichnisbaum des Projektes angezeigt wird. Dort kann man
alle vorhanden Dateien ansehen, umbenennen, hochladen oder auch löschen. Das
gleiche gilt für Unter-Ordner.&lt;/p&gt;
&lt;p&gt;In der mittleren Spalte wird der Quellcode der geöffneten Datei angezeigt, welches
in der Regel die &amp;ldquo;.tex&amp;rdquo; Dateien sind, aber auch Bilder lassen sich anzeigen.
In der rechten Spalte sieht man die Vorschau des kompilierten Dokumentes. Diese
Vorschau lässt sich mittels des &amp;ldquo;Recompile&amp;rdquo; Button oberhalb des Dokumentes
beliebig oft neugenerieren. Daneben finden sich noch Buttons um Warnungen vom
LaTeX-Compiler anzuzeigen und es besteht ebenfalls die Möglichkeit das Dokument
herunterzuladen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/sharelatex_projekt.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die Standard-Oberfläche in einem Projekt.&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/sharelatex_projekt.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Zwischen der mittleren und der rechten Spalte findet sich eine nützliche Funktion
in der man entweder von einer Quellcode-Position zu der entsprechenden Seite
im Dokument springen kann. Alternativ funktioniert das auch anders herum, sodass
man von der entsprechenden Stelle im Dokument an die richtige Stelle im Quellcode
springen kann.&lt;/p&gt;
&lt;p&gt;Am oberen Rand der Web-Oberfläche finden sich ebenfalls noch ein paar weitere
Buttons, hinter denen sich eine nützliche Funktionen verbergen. Ganz rechts
befindet sich ein Button um eine Chat-Leiste einzublenden. Dort ist ein simpler
Chat enthalten, damit sich Projekt-Mitarbeiter dort unterhalten können. Daneben
kann man auch die letzten Änderungen anzeigen lassen, die im Projekt durchgeführt
worden sind. Es werden nicht nur die eigenen Änderungen angezeigt, sondern
die aller Projekt-Mitarbeiter. Diese Projekt-Mitarbeiter müssen natürlich
zuvor hinzugefügt werden. Daher verbirgt sich hinter dem Share-Button die Möglichkeit
eine E-Mail Adresse anzugeben, damit ein Nutzer das Projekt entweder nur Lesen
oder auch Lesen und Änderungen durchführen kann. Wenn der E-Mail Versand korrekt
eingerichtet worden ist, wird eine E-Mail versendet, alternativ kann sich der
Nutzer mit der angegebenen E-Mail Adresse auch selbst registrieren, um auf das
Projekt zugreifen zu können.&lt;/p&gt;
&lt;p&gt;Am linken Rand der oberen Leiste in der Web-Oberfläche befindet sich ein Menü
um weitere Einstellungen am Projekt durchzuführen. Da kann man etwa den Compiler
anpassen, das Theme des Editors anpassen oder auch die Schrift-Größe anpassen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/sharelatex_menu.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Das Menü innerhalb eines Projektes.&#34;&gt;
    &lt;img src=&#34;https://svij.org/graphics/sharelatex_menu.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;ShareLaTeX bietet eine gute Möglichkeit um kollaborativ an LaTeX-Dokumenten
zu Arbeiten. Die Änderungen jedes Projekt-Mitarbeiters können einfach nachvollzogen
werden und auch ein Chat ist integriert um sich auf kurzem Wege zu unterhalten.
Sinnvoll ist der Einsatz auch, wenn man häufig an verschiedenen Rechnern sitzt
und nicht überall die gleiche LaTeX-Installation vorzuweisen hat. Ebenfalls
kann man, wenn man etwa an akademischen Arbeiten sitzt, einfach andere Leute
einladen um etwa Korrekturen zu machen. Nachteillig ist nur die etwas umständliche
Installation, sowie die relativ hohe Last auf dem Server, da schon bei einem Nutzer
knapp 750MB an Arbeitsspeicher für ShareLaTeX (inklusive des Systems) gebraucht werden.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Was ist Git?</title>
      <link>https://svij.org/blog/2015/01/05/was-ist-git/</link>
      <pubDate>Mon, 05 Jan 2015 20:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2015/01/05/was-ist-git/</guid>
      <description>&lt;p&gt;Zur Entwicklung von Software wird in der Regel ein Versionsverwaltungsprogramm genutzt. Es gibt zahlreiche Anwendungen um dies zu erledigen, zu den bekannteren Programmen gehören Subversion, CVS, Mercurial, Bazaar und eben Git. Dieser Artikel gibt einen Überblick über Git, was es ist, wie man es einsetzen kann und wie es funktioniert.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Hinweis:&lt;/strong&gt; Einigen Lesern dürfte die erste Hälfte bekannt vorkommen. Dies erschien in ähnlicher Fassung bereits im &lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/&#34;&gt;ersten Teil des Git-Tutorials&lt;/a&gt;.&lt;/p&gt;
&lt;h3 id=&#34;was-ist-eine-versionsverwaltung&#34;&gt;Was ist eine Versionsverwaltung?&lt;/h3&gt;
&lt;p&gt;Für die Leser, die noch keine Erfahrung oder Ahnung von Versionsverwaltungsprogrammen haben, ist es zunächst wichtig zu wissen, was denn genau ein solches Programm macht. Die Bedeutung einer Versionsverwaltung lässt sich schon fast aus dem Wort ableiten: Es handelt sich um das Verwalten von Versionen. Konkret heißt dies, dass man von Dateien Versionen erzeugen kann, die dann sinnvoll verwaltet werden. Einzelne Versionen beinhalten keineswegs nur große Änderungen, sondern sehr wohl auch kleinere Änderungen.&lt;/p&gt;
&lt;p&gt;Viele kennen es: Man geht einer Tätigkeit nach – sei es an einem Text, einem Bild oder an einem Video – und man möchte den aktuellen Stand immer mal wieder zwischenspeichern, damit man zum einen eine Sicherung der Datei hat und zum anderen wieder auf eine ältere Version zurückspringen kann, wenn etwas falsch gelaufen ist. Jede Person hat dabei verschiedene Ansätze, die einzelnen Versionen irgendwo abzulegen. Die eine Person fügt jeweils eine Versionsnummer in den Dateinamen ein, eine andere Person macht sich wiederum einzelne Ordner für jede Version mit dem aktuellen Datum, in dem die einzelnen Stände gesichert werden.
Wirklich praktikabel und effizient sind keine der beiden genannten Varianten, da sich sehr schnell und sehr einfach Fehler einschleichen, etwa wenn man alte Revisionen löscht, die man gegebenenfalls hinterher doch wieder braucht.&lt;/p&gt;
&lt;p&gt;Genau hier kommen Versionsverwaltungssysteme ins Spiel. Mit einer Versionsverwaltung werden zusätzlich zu den reinen Veränderungen noch weitere Informationen zu einer Version gespeichert. Darunter fallen Informationen zum Autor, der Uhrzeit und eine Änderungsnotiz. Diese werden bei jedem Versionswechsel gespeichert. Durch die gesammelten Dateien lässt sich so schnell und einfach eine Änderungshistorie anzeigen und verwalten. Falls zwischendurch Fehler in den versionierten Dateien aufgetreten sind, kann man dann wieder zurück zu einer Version springen, um von dort aus erneut weiter zu machen. Dabei ist es ganz egal, um was für eine Art von Dateien es sich handelt. Am häufigsten werden Versionsverwaltungsprogramme zur Software-Entwicklung eingesetzt. Ein ziemlich ähnliches Konzept findet sich auch im Wiki von ubuntuusers.de. So besitzt jede Wiki-Seite ebenfalls eine Änderungshistorie, wie man es beispielsweise am Wiki-Artikel zu &lt;a href=&#34;http://wiki.ubuntuusers.de/ubuntuusers?action=log&#34;&gt;ubuntuusers&lt;/a&gt; selbst sehen kann.&lt;/p&gt;
&lt;p&gt;Aber nicht nur für Programmierer ist eine Versionsverwaltung sinnvoll; wie bereits geschrieben, kann der Einsatz zum Beispiel auch für Grafiker oder Autoren durchaus nützlich sein. Ein Grafiker könnte sich so Versionen von bearbeiteten Bildern speichern, um bei misslungenen Änderungen wieder zurückspringen zu können. Bei Autoren geht es um Text, der ähnlich dem Quellcode von Software-Projekten gut verwaltet werden kann. Vor allem bei kollaborativen Arbeiten zahlt sich der Einsatz von Git oder einem anderen Versionsverwaltungsprogramm aus. Jeder Mitarbeiter kann so seine Änderungen einem Projekt hinzufügen und so kann sehr gut nachverfolgt werden, welche Person aus welchen Gründen und zu welcher Zeit eine Änderung durchgeführt hat. Dieser Vorteil spielt sich besonders bei Text-Dateien aus, da man hier Zeile für Zeile überprüfen kann, welche Änderungen gemacht worden sind.&lt;/p&gt;
&lt;p&gt;Es gibt drei verschiedene Konzepte zur Versionsverwaltung: die lokale, zentrale und die verteilte Versionsverwaltung.&lt;/p&gt;
&lt;h4 id=&#34;lokale-versionsverwaltung&#34;&gt;Lokale Versionsverwaltung&lt;/h4&gt;
&lt;p&gt;Die lokale Versionsverwaltung ist wohl eher selten in produktiven Umgebungen zu finden, da sie lediglich lokal arbeitet und häufig auch nur einzelne Dateien versioniert. Das oben bereits erwähnte manuelle Erzeugen von Versionen von Dateien wäre zum Beispiel eine lokale Versionsverwaltung mit einer einzelnen Datei. Sie ist zwar ziemlich einfach zu nutzen, allerdings resultiert daraus eine hohe Fehleranfälligkeit und sie ist zudem wenig flexibel. Echte lokale Versionsverwaltungssoftware gibt es mit &lt;a href=&#34;https://de.wikipedia.org/wiki/Source_Code_Control_System&#34;&gt;SCCS&lt;/a&gt; und &lt;a href=&#34;https://de.wikipedia.org/wiki/Revision_Control_System&#34;&gt;RCS&lt;/a&gt; auch. Der wohl größte Minuspunkt der lokalen Versionsverwaltung ist, dass man standardmäßig nicht mit mehreren Personen an Dateien arbeiten kann. Außerdem besteht keinerlei Datensicherheit, da die Daten nicht zusätzlich auf einem entfernen Server liegen, sofern nicht zusätzliche Backups durchgeführt werden.&lt;/p&gt;
&lt;h4 id=&#34;zentrale-versionsverwaltung&#34;&gt;Zentrale Versionsverwaltung&lt;/h4&gt;
&lt;p&gt;Eine zentrale Versionsverwaltung ist hingegen häufig in produktiven Umgebungen zu finden. &lt;a href=&#34;https://de.wikipedia.org/wiki/Subversion&#34;&gt;Subversion&lt;/a&gt; und &lt;a href=&#34;https://de.wikipedia.org/wiki/Concurrent_Versions_System&#34;&gt;CVS&lt;/a&gt; (Concurrent Versions System) sind beispielsweise Vertreter der zentralen Versionsverwaltung. Hauptmerkmal ist, dass das Repository lediglich auf einem zentralen Server liegt. „Repository“ ist ein englisches Wort für „Lager“, „Depot“ oder „Quelle“. Ein Repository ist somit ein Lager, in dem die Daten liegen. Autorisierte Nutzer eines Repositorys arbeiten dabei lokal mit einer Arbeitskopie der im Repository vorhandenen Dateien. Die Logik der Versionsverwaltung liegt dabei auf dem zentralen Server. Wenn man also auf eine andere Revision wechseln möchte oder sich die Revisionsänderungen anschauen möchte, werden stets die Daten vom Server heruntergeladen.&lt;/p&gt;
&lt;h4 id=&#34;verteilte-versionsverwaltung&#34;&gt;Verteilte Versionsverwaltung&lt;/h4&gt;
&lt;p&gt;Zu den verteilten Versionsverwaltungssystemen gehört nicht nur &lt;a href=&#34;http://git-scm.com/&#34;&gt;Git&lt;/a&gt;, sondern unter anderem auch &lt;a href=&#34;http://bazaar.canonical.com/en/&#34;&gt;bazaar&lt;/a&gt; oder &lt;a href=&#34;http://mercurial.selenic.com/&#34;&gt;Mercurial&lt;/a&gt;. Im Gegensatz zur zentralen Versionsverwaltung besitzt jeder Nutzer des Repositorys nicht nur eine Arbeitskopie, sondern das komplette Repository. Wenn also zwischen verschiedenen Revisionen gewechselt wird oder man sich die letzten Änderungen anschauen möchte, muss nur einmal das Repository geklont werden. Danach stehen alle Funktionalitäten der Versionsverwaltung offline zur Verfügung. Dadurch wird nicht nur unnötiger Netzwerktraffic vermieden, sondern auch die Geschwindigkeit wird, durch den fehlenden Netzwerk-Overhead, deutlich erhöht. Zusätzlich besitzen verteilte Versionsverwaltungssysteme eine höhere Datensicherheit, da die Daten des Repositorys in der Regel auf vielen Rechnern verteilt liegen. Dies ist somit quasi eine Kombination der beiden Konzepte der zentralen und lokalen Versionsverwaltung.&lt;/p&gt;
&lt;h3 id=&#34;geschichtliches&#34;&gt;Geschichtliches&lt;/h3&gt;
&lt;p&gt;Lange Zeit nutzten die Entwickler des Linux-Kernels das proprietäre Versionsverwaltungssystem &lt;a href=&#34;http://www.bitkeeper.com&#34;&gt;BitKeeper&lt;/a&gt;. Nach einer Lizenzänderung seitens der Herstellerfirma von BitKeeper konnte das Team um den Linux-Kernel, allen voran Linus Torvalds, BitKeeper nicht mehr kostenfrei verwenden, weswegen Linus Torvalds mit der Entwicklung von Git begann.&lt;/p&gt;
&lt;p&gt;Da die Entwicklung im Jahr 2005 begann, gehört Git zu den jüngeren Versionsverwaltungssystemen. Für Linus Torvalds war es wichtig, dass das künftige Versionsverwaltungssystem drei spezielle Eigenschaften besitzt. Dies ist zum einen Arbeitsabläufe, die an BitKeeper angelehnt sind, Sicherheit gegen böswillige und unbeabsichtigte Verfälschung des Repositorys, sowie eine hohe Effizienz. Das Projekt &lt;a href=&#34;http://www.monotone.ca/&#34;&gt;Monotone&lt;/a&gt;, ebenfalls ein Versionsverwaltungssystem, wäre fast perfekt gewesen. Es fehlte lediglich die Effizienz. Mit Git erschuf Linus Torvalds dann doch eine eigene Versionsverwaltung, die nicht auf den Quellen von Monotone oder BitKeeper beruht.&lt;/p&gt;
&lt;p&gt;Interessant ist auch die Namensnennung von Git. Git ist das englische Wort für „Blödmann“. Linus Torvalds selbst sagte spaßeshalber: „I&amp;rsquo;m an egoistical bastard, and I name all my projects after myself. First &amp;lsquo;Linux&amp;rsquo;, now &amp;lsquo;Git&amp;rsquo;.“ (Deutsch: „Ich bin ein egoistischer Mistkerl, und ich nenne alle meine Projekte nach mir selbst. Erst &amp;lsquo;Linux&amp;rsquo; und nun &amp;lsquo;Git&amp;rsquo;.“) Natürlich gibt es auch praktische Gründe, das Projekt „git“ zu nennen. Zum einen enthält das Wort lediglich drei Buchstaben, was das Tippen auf der Tastatur erleichtert, zum anderen gab es kein gebräuchliches UNIX-Kommando, mit dem es kollidieren würde.&lt;/p&gt;
&lt;h3 id=&#34;arbeiten-mit-git&#34;&gt;Arbeiten mit Git&lt;/h3&gt;
&lt;p&gt;Wie oben schon einmal kurz angerissen, ist ein Git ein verteiltes Versionsverwaltungsprogramm. Das ganze Repository mit all ihren Informationen liegt dabei nicht nur auf dem Server sondern auch auf dem lokalen Rechner. Dieser Fakt ist ein zentraler Punkt um mit Git sinnvoll arbeiten zu können und um das Konzept dahinter zu verstehen.&lt;/p&gt;
&lt;p&gt;Ein Git-Repository besteht aus mehreren Bestandteilen. Allumfassend ist das Repository, welches diverse Branches besitzt. Branches wiederum bestehen aus mehreren Commits. Dieses Kapitel geht auf die Eigenschaften ein, aus denen ein Repository besteht und beantwortet einige Fragen.&lt;/p&gt;
&lt;h3 id=&#34;was-ist-ein-commit&#34;&gt;Was ist ein Commit?&lt;/h3&gt;
&lt;p&gt;Kurz ausgedrückt stellt ein Commit in einem Repository eine Änderung dar. In einem Commit werden mehrere Informationen erfasst und gespeichert. Darunter fällt der Zeitpunkt des Commits, der Autor, eine Änderungsnotiz und die Änderung selbst. Die Änderung selbst kann groß und klein sein. Man kann etwa vollständig neue Dateien dem Repository hinzufügen oder auch nur eine kleine Sache in einer Datei ändern. Auch ein Löschen von Zeilen oder einer ganzen Datei sind eine Änderung und können in einem Commit erfasst werden. Neben den bereits genannten Punkten besitzt jeder Commit eine eindeutige Hash-Summe mit der sie kollisionsfrei referenziert werden kann.&lt;/p&gt;
&lt;p&gt;Wichtig beim Arbeiten mit Git und vorallem beim kollaborativen Arbeiten ist, dass man sinnvolle Commits bildet. Auch wenn sich dies auf dem ersten Blick einfach liest, kann man da doch einiges falsch beziehungsweise ungünstig machen. Es gibt kein allgemeingültiges Rezept für gute Commits, auch unterscheiden sich in diesem Punkt die Ansichtsweisen von Git-Nutzern.&lt;/p&gt;
&lt;p&gt;Insbesondere beim Entwickeln von Software ist es sinnvoll, wenn man jeden Commit thematisch abgrenzt. Der Commit selbst sollte durch die Commit-Nachricht, also der Änderungsnotiz, angemessen beschrieben werden. Wenn man zum Beispiel in einer Software ein paar Icons auswechselt, ist es ratsam hierfür einen Commit zu erstellen. Was man in dem Zuge nicht machen sollte, ist etwa Änderungen am Code und an Grafiken innerhalb eines Commits zu vermischen. Passende Commit-Nachrichten sind ebenfalls angebracht, da man hinterher sehr gut  und auch einfacher überblicken kann, warum man eine Änderung gemacht hat und was diese enthält. Commit-Nachrichten wie „Aktueller Stand“ sollte man daher möglichst vermeiden.&lt;/p&gt;
&lt;h3 id=&#34;was-ist-ein-branch&#34;&gt;Was ist ein Branch?&lt;/h3&gt;
&lt;p&gt;Ein wichtiges Element von Git und auch anderen Versionsverwaltungsprogrammen ist das Arbeiten mit Branches. Das Wort „Branch“ lässt sich in diesem Fall am Besten mit „Zweig“ übersetzen. Es ist möglich, den aktuellen Entwicklungsstand abzuzweigen und daran weiter zu entwickeln. Konkret bedeutet dies, dass quasi eine Kopie vom aktuellen Arbeitsstand erzeugt wird und man dort weitere Commits tätigen kann, ohne eine andere Entwicklungslinie zu berühren. Die Nutzung von Branches ist eine zentrale Eigenschaft von Git, insbesondere in der Software-Entwicklung. In der Praxis sieht das dann meistens so aus, dass einzelne Features in einzelnen Branches entwickelt werden und dann nach und nach in den Haupt-Entwicklungszweig zusammengeführt werden. Häufig ist es allerdings so, dass man auch noch ältere Versionen pflegt, die etwa noch mit Sicherheitsaktualisierungen versorgt werden müssen. So kann man recht einfach von einem Entwicklungszweig auf einen anderen Branch wechseln und dort noch schnell einen Fehler korrigieren. Anschließend kann man wieder zurück wechseln und an seinem Feature weiterarbeiten. Das ganze Vorgehen hilft den Programmierern zwischen verschiedenen Versionen und Entwicklungslinien zu springen, ohne großen Aufwand betreiben zu müssen.&lt;/p&gt;
&lt;h3 id=&#34;was-heißt-mergen&#34;&gt;Was heißt Mergen?&lt;/h3&gt;
&lt;a href=&#34;https://svij.org/graphics/git-docker.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Ein Blick in das Docker-Repository mit vielen Commits und gemergten Branches.&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/git-docker.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Wie bereits erwähnt, werden häufig einzelne Features in Software-Projekten in einzelnen Branches entwickelt. Dies hat den Vorteil, dass man sich auf die Arbeit an diesem einzelnen Feature konzentrieren kann und nicht von anderen Änderungen von anderen Features betroffen ist. Wenn ein Entwicklung allerdings abgeschlossen ist, will man diese Änderungen natürlich wieder in den Hauptentwicklungs-Branch integrieren. In größeren Projekten tut sich auf diesen Branch auch einiges, so dass diese beiden Branches vereinigt werden müssen. Den Prozess des Vereinigens nennt man „mergen“. Mit einem simplen Befehl können so zwei Entwicklungslinien miteinander verschmolzen werden. Dies funktioniert allerdings nicht immer einwandfrei und problemlos. So kann es nämlich vorkommen, dass in beiden Branches Änderungen an der selben Zeile durchgeführt worden sind. Hierbei kann es dann zu Merge-Konflikten kommen, die dann vom jeweiligen Entwickler händisch gelöst werden müssen.&lt;/p&gt;
&lt;p&gt;Für Entwickler bieten Branches und das Mergen eine einfache und schnelle Möglichkeit, einige Dinge zu testen. So kann man fix einen Branch anlegen, wenn man eine bestimmte Änderung testen möchte, die man nicht in seinem Entwicklungs-Branch haben möchte. Falls man mit der Änderung zufrieden ist, kann man sich dann auch ganz einfach mergen oder eben auch verwerfen. So stört man nicht den Entwicklungsfluss im Hauptentwicklungs-Branch sondern kann auch kurze einfache Tests durchführen ohne das es andere Entwickler im Team stört.&lt;/p&gt;
&lt;h3 id=&#34;was-sind-remote-repositorys&#34;&gt;Was sind Remote-Repositorys?&lt;/h3&gt;
&lt;p&gt;Eine weitere große Stärke von Git ist, dass man ein Repository auf vielen verschiedenen Rechnern verteilen kann. Ein vollständiges Git-Repository kann an vielen verschiedenen Orten liegen. Wichtig für das Verständnis ist, dass in der Theorie jedes Git-Repository mit jedem gleichgestellt ist. In der Praxis sieht das allerdings etwas anders aus, da meistens bei Projekten mit einem zentralen Server gearbeitet wird.&lt;/p&gt;
&lt;p&gt;Entfernt liegende Repositories nennt man Remote-Repositorys. Es bietet sich grundsätzlich immer an, mit Remote-Repositorys zu arbeiten. Ein Projekt, dessen Git-Repository nur auf einem lokalen Rechner liegt, ist kaum vor Ausfällen gesichert. Sie sind insbesondere deshalb nützlich, da man damit einfach kollaborativ arbeiten kann.&lt;/p&gt;
&lt;p&gt;Remote-Repositorys können an verschiedenen adressierbaren Stellen lagern. Darunter fällt auch der lokale Rechner, was aber, wie oben schon erwähnt, nicht sonderlich praktikabel ist. Es gibt verschiedene Dienste um git auf dem Server zu betreiben. Dies kann man entweder selbst hosten, oder aber externe Dienste wie &lt;a href=&#34;https://github.com&#34;&gt;GitHub&lt;/a&gt; nutzen.&lt;/p&gt;
&lt;h4 id=&#34;welche-schichten-gibt-es-beim-einsatz-von-git&#34;&gt;Welche Schichten gibt es beim Einsatz von Git?&lt;/h4&gt;
&lt;p&gt;Beim Einsatz von Git ist es wichtig zu verstehen, welche verschiedenen Schichten es gibt. Die Schichten sind nicht fest an ein einzelnes Repository gebunden sondern gehen darüber hinaus auf den ganzen Entwicklungsprozess mitsamt Remote-Repositorys ein. Insgesamt gibt es beim Arbeiten mit Git fünf Schichten die man kennen muss, die im folgenden erläutert werden.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git-projektvorstellung.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Das Konzept von Git lässt sich gut in Schichten darstellen.&#34;&gt;
  &lt;img src=&#34;https://svij.org/graphics/git-projektvorstellung.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;h5 id=&#34;remote-repository&#34;&gt;Remote-Repository&lt;/h5&gt;
&lt;p&gt;Remote-Repositorys wurden schon in diesem Artikel erläutert. An jedem lokalen Repository kann man mehrere Remote-Repositorys konfigurieren, wo man seine Änderungen abholen und hinschieben kann. Natürlich unter der Voraussetzung, dass man die nötigen Berechtigungen für das entsprechende Remote-Repository besitzt.&lt;/p&gt;
&lt;h5 id=&#34;lokales-repository&#34;&gt;Lokales Repository&lt;/h5&gt;
&lt;p&gt;Das lokale Repository erklärt sich schon fast selbst. Das ist der Teil des Repositorys, welches auf dem lokalen Rechner befindet. Dies umfasst insbesondere &amp;lsquo;&amp;rsquo;nicht&amp;rsquo;&amp;rsquo; die Dateien des Repositorys, mit denen man arbeitet. Das lokale Repository ist als &amp;lsquo;&amp;rsquo;.git&amp;rsquo;&amp;rsquo;-Unterordner im Projekt enthalten. Darin sind alle Informationen des Repositorys enthalten, wie etwa die Commits und die Branches.&lt;/p&gt;
&lt;h5 id=&#34;index&#34;&gt;Index&lt;/h5&gt;
&lt;p&gt;Der Index wird häufig auch Staging-Bereich genannt. Im Index landen alle Dateien, die man für ein Commit vormerkt. Dieser Bereich ist daher in der Regel nicht persistent, da man nur solange den Index mit Dateien beziehungsweise Änderungen an Dateien füllt, bis man einen Commit getätigt hat.&lt;/p&gt;
&lt;h5 id=&#34;workspace&#34;&gt;Workspace&lt;/h5&gt;
&lt;p&gt;Der Workspace, auch Arbeitsbereich genannt, ist der Teil des Repositorys, welches die Dateien enthält, mit denen man arbeitet. Das heißt, wenn man ein Repository von einem Remote-Repository geklont hat, also eine Kopie heruntergeladen hat, dann umfasst der Workspace bei einem Software-Projekt den Quellcode. Im Unterschied zum lokalen Repository, enthält der Workspace keinerlei Informationen über andere Branches. Man spricht beim Workspace auch von „ausgescheckten“ Dateien, da der Workspace eine Revision des Repositorys darstellt.&lt;/p&gt;
&lt;h5 id=&#34;stash&#34;&gt;Stash&lt;/h5&gt;
&lt;p&gt;Stash kann man gut mit „Lager“ oder „Geheimversteck“ übersetzen. Im Kontext von Git kann man geänderte Dateien, die man noch nicht committen möchte, kurzfristig in den Stash legen. Dies ist insbesondere dann sinnvoll, wenn zwar an einigen Dateien gearbeitet hat, aber man noch kurzfristig eine Änderung auf einem anderen Branch machen möchte. Die geänderten Dateien lassen sich so schnell in den Stash verschieben und bei Bedarf wieder herausholen.&lt;/p&gt;
&lt;h3 id=&#34;ist-git-gleich-github&#34;&gt;Ist Git gleich GitHub?&lt;/h3&gt;
&lt;p&gt;Git-Repositorys möchte man idealerweise auf einem Server lagern, den man über das öffentliche Internet erreichen kann. Es gibt mehrere Möglichkeiten Git auf dem Server zu installieren. Wenn man hingegen nicht ein eigenen Git-Server einrichten möchte, kann man auch externe Dienste verwenden. Der bekannteste Dienst ist wohl &lt;a href=&#34;https://github.com&#34;&gt;GitHub&lt;/a&gt;. Einige Personen setzen Git und GitHub gleich, was allerdings so nicht stimmt. Weder ist Git selbst GitHub, noch ist GitHub Git! Grob gesagt, ist GitHub eine Erweiterung von Git um kollaborativ oder auch alleine an einem Projekt zu arbeiten. Viele Open-Source-Projekte hosten ihre Git-Repositorys auf GitHub, darunter &lt;a href=&#34;https://github.com/mozilla&#34;&gt;GitHub&lt;/a&gt;, &lt;a href=&#34;https://github.com/php&#34;&gt;PHP&lt;/a&gt; und auch die ubuntuusers.de-Software Inyoka. GitHub vereinfacht den Austausch zwischen den Teilnehmern an einem Projekt, da man dort nicht nur Fehler an einem Projekt melden kann, sondern theoretisch auch direkt selbst korrigieren kann.&lt;/p&gt;
&lt;p&gt;GitHub arbeitet stark mit sogenannten „Forks“. Fork ist der englische Begriff für „Gabel“. Ein Fork ist allerdings in diesem Kontext eine Abspaltung eines Projekts. Bei einigen Projekten sieht man des öfteren Slogans wie „Fork us on GitHub“. Wenn man einen GitHub-Account besitzt und dann ein Projekt forkt, dann legt GitHub im eigenen Benutzer-Konto ein Klon des Repositorys an, wo man selbst Schreibrechte besitzt. So kann man die gewünschten Änderungen selbst durchführen, diese commiten und anschließend das Repository wieder auf GitHub pushen. Die Änderungen sind dann zwar im eigenen Fork online, sollten aber dem Hauptprojekt zurückgeführt werden. Dafür bietet GitHub die „Pull-Request“-Funktion an. Ein Pull-Request ist prinzipiell nichts weiter als eine Bitte die eigenen durchgeführten Änderungen in das Haupt-Repository zu „pullen“, also einzufügen. Nach Prüfung kann man dann per Knopfdruck im Browser die Änderungen in das Haupt-Repository übernommen werden.&lt;/p&gt;
&lt;p&gt;Die erläuterten Funktionen beschränken sich auf die gängigsten Funktionen von GitHub. Es gibt noch einige weitere Funktionen die allerdings den Rahmen des Artikels sprengen würden. GitHub wird häufig auch als „Social-Coding“ Plattform bezeichnet, da man nicht nur einfach zu anderen Entwicklern in Kontakt treten kann, sondern auch deren Entwicklungen verfolgen kann.&lt;/p&gt;
&lt;p&gt;GitHub ist nicht die einzige Plattform, die solche Funktionen abbildet. Es gibt auch weitere Plattformen wie etwa &lt;a href=&#34;https://bitbucket.org&#34;&gt;BitBucket&lt;/a&gt;. Am verbreitetsten ist jedoch GitHub. Für die Entwicklung von Ubuntu wird hauptsächlich &lt;a href=&#34;https://launchpad.net/&#34;&gt;Launchpad&lt;/a&gt; verwendet, welches man mit GitHub vergleichen kann. Allerdings nutzt Launchpad nicht Git, sondern Bazaar. Nachteilig von GitHub ist allerdings, dass die Software selbst nicht Open Source ist und jedes einzelne Repository mit einem kostenlosen Account öffentlich ist. Für private, nicht öffentliche Repositorys muss man dort zahlen.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Der Einsatz von Git eignet sich zwar besonders für Software-Entwickler, doch auch für Autoren oder Grafiker kann sich ein Einsatz von Git lohnen, um zum einen eine Versionshistorie zu haben und zum anderen auch gut mit anderen kollaborieren kann.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>tmux mit byobu nutzen</title>
      <link>https://svij.org/blog/2014/12/14/tmux-mit-byobu-nutzen/</link>
      <pubDate>Sun, 14 Dec 2014 13:20:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/12/14/tmux-mit-byobu-nutzen/</guid>
      <description>&lt;p&gt;Mit dem Programm tmux ist es möglich laufende Terminal-Programme von der
aktuellen Sitzung zu trennen und wieder anzuhängen. Die darin laufenden
Programme laufen im Hintergrund weiter. Byobu erweitert einige Funktionen
von tmux und erleichtert den Einsatz und den Umgang mit tmux.&lt;/p&gt;
&lt;p&gt;Das Programm tmux wurde in der &lt;a href=&#34;http://www.freiesmagazin.de/20140504-maiausgabe-erschienen&#34;&gt;Mai-Ausgabe 2014&lt;/a&gt;
bereits ausführlich von Wolfgang Hennerbichler beschrieben. Byobu selbst
ist mehr ein Erweiterungs-Script bzw. ein Hilfsprogramm, welches auf tmux aufbaut.
Byobu bietet unter anderem eine einfach zu konfigurierende Statusbar, wo man
nicht viel Zeit und Aufwand in der Erstellung von Konfigurationsdateien stecken
muss.&lt;/p&gt;
&lt;p&gt;Byobu lässt sich einfach über die Paketverwaltung installieren, sofern es in
den Paketquellen der verwendeten Distribution vorhanden ist. Ubuntu beispielsweise
bietet eine Version in den Paketquellen an.&lt;/p&gt;
&lt;h2 id=&#34;der-erste-start&#34;&gt;Der erste Start&lt;/h2&gt;
&lt;p&gt;Byobu kann im Terminal mit dem eigenen Namen gestartet werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ byobu
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Nach dem Starten erscheint am unteren Fensterrand eine Status-Leiste, wie man
es von Screen oder tmux gewohnt ist. Im Gegensatz zu eben diesen Programmen
werden in byobu im Standard schon einige Informationen über die laufende Sitzung
und über das System angezeigt. Darunter fällt die etwa die aktuelle Uhrzeit, die
Anzahl der verfügbaren Aktualisierungen, die Uptime oder auch der aktuelle RAM-Verbrauch.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/byobu_statusbar.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die Standard-Statusbar von byobu unter Ubuntu 14.04.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/byobu_statusbar.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Byobu lässt sich über zwei Arten steuern. Wenn man etwa neue Sitzungen öffnen
oder zwischen den geöffneten Sitzungen wechseln möchte, dann kann man dies
über die Funktionstasten (F-Tasten) tun. Durch das Drücken der Taste F2 öffnet
sich eine etwa eine neue Sitzung, welches häufig Tab auch genannt. Wenn man hingegen
zwischen den Sitzungen wechseln möchte, kann man mit F3 zur vorherigen Sitzung
nach links oder mit F4 zur nächsten Sitzung nach rechts wechseln.&lt;/p&gt;
&lt;p&gt;Die Steuerung von byobu über die Funktionstasten ist nicht die einzige Möglichkeit.
Nutzer von Screen oder tmux sind etwa die Steuerung über Tastenkombination STRG + A
gewohnt. Sobald man diese Tastatenkombination auf einer frischen byobu Installation
durchführt, öffnet sich eine Abfrage in der Konsole, welches Verhalten man
für die Tastenkombination wünscht. Angeboten werden zwei Varianten, die erste
Variante ist die Nutzung des Screen-Modus, alternativ kann man den Emacs-Modus
verwenden. Der Emacs-Modus ist das Standard Konsolen-Verhalten. In einer normalen
Konsole verschiebt sich der Cursor auf den Anfang der Zeile, beim Drücken von
STRG + A.&lt;/p&gt;
&lt;h2 id=&#34;konfiguration&#34;&gt;Konfiguration&lt;/h2&gt;
&lt;p&gt;Wie bereits erwähnt, lassen sich diverse Informationen in der Statusbar darstellen.
Hierfür muss man keine Konfigurationsdateien anpassen. Durch das Drücken der
F9-Taste öffnet sich zunächst das Konfigurationsmenü von byobu.&lt;/p&gt;
&lt;p&gt;Der erste Punkt ist die Hilfe, in der alle nötigen und vorhanden Tasten-Kombinationen
aufgeführt und kurz erläutert werden. Darunter fallen sowohl das simple Wechseln
zwischen den Sitzungen, als auch etwas komplexere Dinge wie das gleichzeitige
Anzeigen zweier Sitzungen auf dem Bildschirm.&lt;/p&gt;
&lt;p&gt;Im zweiten Menü-Punkt kann man die Statusmeldungen in der unteren Statusbar
bearbeiten. Dort lassen sich über 30 Informationen aktivieren oder deaktivieren.
Je nach Einsatzzweck und persönlichen Vorlieben kann man so die ein oder andere
Option aktivieren. So kann man etwa den Hostname, die IP oder auch Informationen
über die CPU, Festplatte, RAM oder Netzwerk darstellen lassen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/byobu_statusmeldungen_config.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Im Konfigurationsmenü kann man diverse Informationen an- und ausschalten.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/byobu_statusmeldungen_config.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Die dritte Option ist die Änderung der Escape-Folge. Dies ist, wenn man sich
im Screen-Modus befindet, die Tastenkombination STRG + A. Sofern gewünscht, kann
man die Escape-Folge auf eine andere Tastenkombination mappen.&lt;/p&gt;
&lt;p&gt;Die letzte Konfigurations-Option ist das automatische Starten von byobu beim Login.
Wenn man diese Funktion aktiviert, muss man hier allerdings beachten, dass dies
in der Regel nur auf das Einloggen in der Konsole ohne graphische Oberfläche bezieht.
Es wirkt sich allerdings auch auf das Einloggen auf einen Rechner per SSH aus.
In beiden Varianten startet beim Einloggen automatisch byobu. Wenn man beispielsweise
auf einem Server byobu installiert hat, bietet es sich ggf. an diese Option zu
aktivieren, da man beim erneuten Verbinden im selben Zustand landet, wie es beim
Schließen der vorherigen Verbindung der Fall war.&lt;/p&gt;
&lt;h2 id=&#34;sonstiges&#34;&gt;Sonstiges&lt;/h2&gt;
&lt;p&gt;Byobu lässt sich nicht nur mit tmux nutzen. Wenn man möchte, kann man auch auf
Screen zurückgreifen. Dazu reicht es folgenden Befehl auszuführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ byobu-select-backend
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann man zwischen tmux oder Screen wechseln. Der Standard ist
allerdings tmux.&lt;/p&gt;
&lt;p&gt;Es ist weiterhin möglich auf einem System mehrere byobu-Sessions zu Starten.
Bei einem Ausführen von &amp;ldquo;byobu&amp;rdquo; im Terminal, öffnet sich, sofern keine Session
vorhanden ist, automatisch eine neue Session. Wenn man allerdings explizit
eine weitere Session starten will, dann ist dies mit dem folgenden Befehl möglich.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ byobu new-session
&lt;/code&gt;&lt;/pre&gt;
&lt;h2 id=&#34;fazit&#34;&gt;Fazit&lt;/h2&gt;
&lt;p&gt;Byobu bietet eine einfache Möglichkeit tmux oder Screen zu nutzen, ohne viel
Aufwand betreiben zu müssen um praktische Informationen in der Statusbar
darstellen zu können. Weiterhin bietet es einen guten Einstieg in die Nutzung
von Terminal-Multiplexer.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Git - kurz &amp; gut</title>
      <link>https://svij.org/blog/2014/11/02/rezension-git-kurz-gut/</link>
      <pubDate>Sun, 02 Nov 2014 20:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/11/02/rezension-git-kurz-gut/</guid>
      <description>&lt;p&gt;Das Buch „Git - kurz &amp;amp; gut“ vom Autor Sven Riedel ist ein kompaktes Taschenbuch
welches in die Nutzung von Git einleitet. Es richtet sich vorallem an
Umsteiger von Nutzern anderer Versionsverwaltungsprogrammen.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Das Buch umfasst neun Kapitel, abgedruckt auf 192 Seiten. Daneben enthält das
Buch ebenfalls noch fünf Anhänge.&lt;/p&gt;
&lt;p&gt;Das erste Kapitel ist die Einleitung. In diesem Teil wird zunächst geklärt,
was Bestandteil des Buches ist und wie die Konventionen sind. Im zweiten Kapitel
folgt anschließend der direkte Einstieg in Git. Dort werden in wenigen Seiten
Konzepte von Git erklärt, etwa den Arbeitsbaum, den Index und was Commits,
Branches, Refs und Tags sind. Weiterhin wird kurz das Thema der Remote-Repositories
angeschnitten. Das dritte Kapitel beinhaltet die Installation von Git. Dabei wird nicht nur
die Installation von Binär-Paketen beschrieben, sondern auch die Kompilierung
aus dem Source-Code.&lt;/p&gt;
&lt;p&gt;Während die ersten drei Kapitel eher einleitende Kapitel waren, geht es erst
in Kapitel 4 richtig los. In diesem Kapitel wird ein erstes Repository angelegt, dieses wird
anschließend konfiguriert und einige Funktionen von Git erläutert. Darunter
fallen zunächst einmal die Versionierungsbefehle, also konkret handelt es
sich dabei um das Hinzufügen von Dateien in den Index, das Erstellen das Rebasen
von den ersten Commits. Weiterhin wird auch noch der Stash, das Mergen und
die Nutzung von Remote-Repositories beschrieben.&lt;/p&gt;
&lt;p&gt;Das fünfte Kapitel behandelt Tipps und Tricks. Dies sind tiefergreifende
Funktionen von Git, die man im tag-täglichen Leben stellenweise eher seltener braucht.
Darunter fallen etwa das Rückgängigmachen von Merges, das Rückgängigmachen
von gelöschten Branches oder auch die Nutzung von eigenen Git Aliases.
Im nachfolgenden sechsten Kapitel wird recht kurz ein Einblick in ein mögliches
Branching-Modell und wie man es mit Git umsetzt.&lt;/p&gt;
&lt;p&gt;Die letzten drei Kapitel sind eher ergänzende Kapitel. Zunächst geht es um
die Nutzung von Github, welches ganz bewusst die oberflächlichen Funktionen
von Github erläutert, da sich dort regelmäßig etwas ändert. GUI-Clients
von Git wurden bis zu Kapitel 8 noch nicht behandelt, was an dieser Stelle
dann getan wird. Das Buch schließt mit dem 9. Kapitel ab, in dem die
Installation und Konfiguration eines Git-Clients mit einem Subversion-Server
vermittelt wird.&lt;/p&gt;
&lt;p&gt;Der fünf-geteilte Anhang enthält weitere Informationen, etwa Vergleiche
zwischen Git und Subversion-Befehlen, Git-Log-Formatierungen, Formate von Commit-Namen,
sowie einen Ausblick auf Git 2.0.&lt;/p&gt;
&lt;h3 id=&#34;wie-liest-es-sich&#34;&gt;Wie liest es sich?&lt;/h3&gt;
&lt;p&gt;Das Buch ist nicht nur ein Taschenbuch sondern auch eine Referenz. Diesen Fakt
merkt man dem Buch auch an, da die Erkläuterungen meistens recht kurz gehalten
sind und diese sind daher meistens auch nicht sonderlich detailreich. Es sind
prinzipiell zwar keine Kenntnisse in der Nutzung von anderen
Versionsverwaltungsprogrammen notwendig, doch könnten Kenntnisse für dieses Buch
schon von Vorteil sein. Es werden häufiger Vergleiche zu Subversion gezogen und
im selben Schritt erläutert, welche ähnliche lautende Befehle jeweils andere
Auswirkungen in Git haben.&lt;/p&gt;
&lt;p&gt;Screenshots, Bilder oder Diagramme sind recht spärlich vorhanden. Manchmal
wäre das ein oder andere zusätzliche Diagramm nützlich, um die Arbeit von
und mit Git besser verbildlichen zu können. Dies wäre vorteilhaft, da der Leser
dann im idealfall schneller versteht. Es sind zwar Abbildungen vorhanden,
die Anzahl ist allerdings relativ überschaubar.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Dieses Buch richtet sich grundsätzlich eher an Subversion-Umsteiger statt
an komplette Neulinge. Diese Information steht zwar in der Einleitung, allerdings
steht dies nicht auf der Zusammenfassung auf der Rückseite des Buches.
Leser, die noch keinerlei Erfahrung mit Versionsverwaltungsprogrammen haben,
könnten Schwierigkeiten mit diesen Buch haben. Die übrigen Leser mit Erfahrung
sollten hingegen keinerlei Probleme haben. Dieses Taschenbuch ist ziemlich
kompakt gehalten, was sich stellenweise am Inhalt auswirkt, da die Erläuterungen
somit ebenfalls ziemlich kurz sind. Grundsätzlich ist das Buch
daher wirklich nur für Umsteiger aus anderen Versionsverwaltungsprogrammen
oder für Sachkundige zu empfehlen, welche ein kleines, günstiges Buch zum
Nachschlagen brauchen.&lt;/p&gt;
&lt;h3 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h3&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; &lt;a href=&#34;http://www.oreilly.de/catalog/gittb2ger/&#34;&gt;Git - kurz &amp;amp; gut&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Sven Riedel&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt; O&amp;rsquo;Reilly&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt; 192 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt; 978-3-95561-734-9&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 12,90€ (broschiert), 9,90€ (E-Book)&lt;/p&gt;
&lt;p&gt;Da es schade wäre, wenn das Buch bei mir im Regal verstaubt,
wird es verlost. Dies ist „drüben“ bei &lt;a href=&#34;http://www.freiesmagazin.de/20141102-novemberausgabe-erschienen&#34;&gt;freiesMagazin&lt;/a&gt;
in den Kommentaren möglich.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git für Einsteiger - Teil 2</title>
      <link>https://svij.org/blog/2014/11/01/git-fur-einsteiger-teil-2/</link>
      <pubDate>Sat, 01 Nov 2014 19:55:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/11/01/git-fur-einsteiger-teil-2/</guid>
      <description>&lt;p&gt;&lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/&#34;&gt;Im ersten Teil&lt;/a&gt;
des Git Tutoriums wurden die ersten Schritte mit Git getätigt:
Zunächst das Anlegen eines Repositories, dann das Hinzufügen und Committen von Dateien
und das Anschauen des Logs. Im zweiten Teil wird nur ein Thema behandelt und
zwar das Branching-Modell von Git.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Dieses Tutorium besteht aus vier Teilen. Wem das Tutorium gefällt und mehr über
Git lernen möchte, der kann sich das Buch &lt;a href=&#34;https://amzn.to/3q0A5Iu&#34;&gt;„Versionsverwaltung mit Git“&lt;/a&gt;
für 29,99€ bestellen. In diesem Buch, was ich geschrieben habe, werden die Themen rund um Git noch
deutlich ausführlicher behandelt.&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;allgemeines-zum-branching&#34;&gt;Allgemeines zum Branching&lt;/h3&gt;
&lt;p&gt;Ein wichtiges Element von Git und auch anderen Versionsverwaltungsprogrammen
ist das Branchen. Das Wort „Branch“ lässt sich in diesem Fall am Besten mit
„Zweig“ übersetzen. Es ist möglich, den aktuellen Entwicklungsstand „abzuzweigen“
und daran weiter zu entwickeln. Konkret bedeutet dies, dass quasi eine Kopie
vom aktuellen Arbeitsstand erzeugt wird und man dort weitere Commits tätigen
kann, ohne die Hauptentwicklungslinie zu berühren. Die Nutzung von Branches
ist eine zentrale Eigenschaft von Git, insbesondere in der Software-Entwicklung.
In der Praxis sieht das dann meistens so aus, dass einzelne Features in einzelnen
Branches entwickelt werden und dann nach und nach in den Haupt-Entwicklungszweig
gemergt werden. Häufig ist es allerdings so, dass man auch noch ältere Versionen
pflegt, die etwa noch mit Sicherheitsaktualisierungen versorgt werden müssen.
So kann man recht einfach von einem Entwicklungszweig auf einen anderen Branch wechseln
und dort noch schnell einen Fehler korrigieren. Anschließend kann man wieder zurück
wechseln und an seinem Feature weiterarbeiten. Das ganze Vorgehen hilft den
Programmierern zwischen verschiedenen Versionen und Entwicklungslinien
zu springen, ohne großen Aufwand betreiben zu müssen.&lt;/p&gt;
&lt;p&gt;Im ersten Teil des Tutoriums wurden bereits drei Commits getätigt. Da kein
spezieller Branch angegeben worden ist, geschah dies automatisch auf dem
Master-Branch. Der Master-Branch ist der Haupt-Zweig, der in vielen Git-Repositories
existiert. Dieser wird automatisch angelegt, wenn man in einem leeren Git-Repository
den ersten Commit tätigt.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-master.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die aktuellen Commits auf dem Master-Branch.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-master.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Die ersten drei Commits wurden, wie oben bereits geschrieben, auf dem Branch &amp;ldquo;master&amp;rdquo;
committed. Die Entwicklung verlief bislang geradlinig, sodass keine Abzweigung
erstellt wurde.&lt;/p&gt;
&lt;p&gt;Beim Arbeiten mit Git, bietet es sich je nach Entwicklungsart häufig an, für jedes
Feature, welches man implementieren möchte, einen eigenen Branch zu erstellen.
Insbesondere deshalb, da oft Features zeitgleich von verschiedenen Entwicklern
implementiert werden.&lt;/p&gt;
&lt;h3 id=&#34;branches-anlegen&#34;&gt;Branches anlegen&lt;/h3&gt;
&lt;p&gt;Die Beispiel-Webseite besitzt aktuell lediglich eine simple Überschrift. Was fehlt,
wäre zum einen ein Inhalt, und zum anderen ein kleines Menü. Für beides sollen eigene
Branches erstellt werden.&lt;/p&gt;
&lt;p&gt;Um sicherzustellen, dass man auf dem richtigen Branch ist, kann man folgenden
Befehl ausführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git branch
* master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Da nur ein Branch aktuell vorhanden ist, wird auch nur der Branch &amp;ldquo;master&amp;rdquo;
angezeigt. Das &amp;ldquo;*&amp;rdquo; vor dem Branchnamen signalisiert, dass es sich um den
Branch handelt, auf dem sich gerade befindet.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git branch menu
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der oben aufgeführte Befehl erzeugt den neuen Branch &amp;ldquo;menu&amp;rdquo;. Wenn man einen Branch
mit dem &amp;ldquo;git branch&amp;rdquo; Befehl erzeugt, wird der Branch zwar angelegt, aber man
wechselt nicht automatisch auf diesen Branch. Dies macht ein erneutes Ausführen
von &amp;ldquo;git branch&amp;rdquo; deutlich:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git branch
* master
  menu
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-menu.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Der Branch &#39;menu&#39; ist noch identisch mit &#39;master&#39;.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-menu.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Jetzt werden beide vorhandenen Branches angezeigt. Man befindet sich allerdings immer noch
auf dem master-Branch. Zum Wechseln des Branches nutzt man den Befehl &amp;ldquo;git checkout&amp;rdquo;.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout menu
Gewechselt zu Branch &#39;menu&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Beim häufigen erzeugen und wechseln zu einem Branch, wären die obigen Befehle
auf Dauer zu lästig, weil man häufig sofort auf dem neu erstellten Branch wechseln will.
Dafür gibt es den kombinierten Befehl:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout -b menu
Gewechselt zu einem neuem Branch &#39;menu&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dieser Befehl legt nicht nur den Branch &amp;ldquo;menu&amp;rdquo; neu an, sondern wechselt
auch direkt auf diesen Branch. Es ist wichtig zu wissen, auf welchem
Branch man sich befindet, wenn man den neuen Branch anlegt.
Dies ist zwar in diesem Beispiel irrelevant, da nur ein Branch existiert,
man sollte es aber stets beachten.&lt;/p&gt;
&lt;p&gt;Als Basis für den neuen Branch wird nämlich immer der aktuelle Commit des aktuellen Branches genommen.
Wenn man sich also auf dem Branch &amp;ldquo;menu&amp;rdquo;
befindet und von dort aus den Branch &amp;ldquo;content&amp;rdquo; erstellt, dann nimmt
er als Basis den aktuellsten Commit von &amp;ldquo;menu&amp;rdquo; und nicht &amp;ldquo;master&amp;rdquo;. Um das Beispiel
fortzuführen, muss daher der Branch &amp;ldquo;content&amp;rdquo; erzeugt werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout -b content
Gewechselt zu Branch &#39;content&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-content.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Drei Branches existieren, die auf dem selben Commit zeigen.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-content.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Zum aktuellen Zeitpunkt existieren drei Branches. Alle fußen auf dem
selben Commit. In diesem Branch, wird nun ein kleiner Inhalt
hinzugefügt, dazu reicht es den &lt;a href=&#34;http://www.loremipsum.de/&#34;&gt;Lorem-Ipsum Generator&lt;/a&gt;
zu nutzen, um einen Fülltext zu erzeugen.&lt;/p&gt;
&lt;p&gt;Unterhalb der &amp;lt;h1&amp;gt; Überschrift in der Datei &amp;ldquo;index.html&amp;rdquo; sollte dann folgendes eingefügt werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;p&amp;gt;
  Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet. Lorem ipsum dolor sit amet, consetetur sadipscing elitr, sed diam nonumy eirmod tempor invidunt ut labore et dolore magna aliquyam erat, sed diam voluptua. At vero eos et accusam et justo duo dolores et ea rebum. Stet clita kasd gubergren, no sea takimata sanctus est Lorem ipsum dolor sit amet.
&amp;lt;/p&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Diese Änderung muss dann aus dem Arbeitsverzeichnis heraus, wie gewohnt committed werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Lorem-Ipsum Fülltext hinzugefügt&amp;quot;
[content 395dd48] Lorem-Ipsum Fülltext hinzugefügt
1 file changed, 3 insertions(+)
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-content2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Durch den neuen Commit ist &#39;content&#39; ein Commit über &#39;master&#39;.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-content2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Jetzt lohnt es sich, das Log mit dem Befehl &amp;ldquo;git log&amp;rdquo; anzusehen. Auf dem aktuellen Branch &amp;ldquo;content&amp;rdquo;
sind vier Commits vorhanden. Es sind nicht nur die ersten drei Commits vor
dem Abzweigen vorhanden, sondern auch der zuletzt hinzugefügte Commit.&lt;/p&gt;
&lt;p&gt;Wechselt man mit &amp;ldquo;git checkout master&amp;rdquo; zurück auf &amp;ldquo;master&amp;rdquo; und
schaut sich dort das Log an, dann sind dort nur drei Commits vorhanden.
Dies hängt damit zusammen, dass Git den Commit nur auf &amp;ldquo;content&amp;rdquo;
ausgeführt hat und eben nicht auf &amp;ldquo;master&amp;rdquo;.
Die Änderungen aus &amp;ldquo;content&amp;rdquo; können in &amp;ldquo;master&amp;rdquo; übernommen werden. Dieser
Schritt folgt allerdings noch nicht an dieser Stelle.&lt;/p&gt;
&lt;p&gt;Es gilt noch die ein oder andere Änderung im Branch &amp;ldquo;menu&amp;rdquo;
durchzuführen. Dazu muss wieder auf den Branch &amp;ldquo;menu&amp;rdquo; wechseln:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout menu
Gewechselt zu Branch &#39;menu&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man nun die Datei &amp;ldquo;index.html&amp;rdquo; Datei zum Bearbeiten öffnet, dann
sind dort die Änderungen mit dem Fülltext nicht enthalten. Das macht auch
Sinn, da die Änderungen auf dem Branch &amp;ldquo;content&amp;rdquo; durchgeführt wurden.&lt;/p&gt;
&lt;p&gt;Die &amp;ldquo;index.html&amp;rdquo;-Datei bekommt nun ein Menü spendiert. Hierfür muss folgender
Code vor der &amp;lt;h1&amp;gt;-Überschrift hinzugefügt werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;nav class=&amp;quot;navbar navbar-default&amp;quot; role=&amp;quot;navigation&amp;quot;&amp;gt;
  &amp;lt;div class=&amp;quot;container-fluid&amp;quot;&amp;gt;
    &amp;lt;div class=&amp;quot;collapse navbar-collapse&amp;quot; id=&amp;quot;bs-example-navbar-collapse-1&amp;quot;&amp;gt;
      &amp;lt;ul class=&amp;quot;nav navbar-nav&amp;quot;&amp;gt;
        &amp;lt;li class=&amp;quot;active&amp;quot;&amp;gt;&amp;lt;a href=&amp;quot;#&amp;quot;&amp;gt;Link&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;
        &amp;lt;li&amp;gt;&amp;lt;a href=&amp;quot;#&amp;quot;&amp;gt;Link&amp;lt;/a&amp;gt;&amp;lt;/li&amp;gt;
      &amp;lt;/ul&amp;gt;
    &amp;lt;/div&amp;gt;
  &amp;lt;/div&amp;gt;
&amp;lt;/nav&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Diese Änderung kann dann ebenfalls wie gewohnt committed werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Bootstrap-Beispiel-Menü hinzugefügt&amp;quot;
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-menu2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Auch &#39;menu&#39; ist ein Commit über &#39;master&#39;.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-menu2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Jetzt fällt aber auf, dass zwar ein Menü vorhanden ist, in beiden Menü Punkten
steht allerdings nur &amp;ldquo;Link&amp;rdquo;. Der Einfachheit halber, reicht es, wenn man an
dieser Stelle den ersten &amp;ldquo;Link&amp;rdquo; mit &amp;ldquo;Home&amp;rdquo; und den zweiten &amp;ldquo;Link&amp;rdquo; mit &amp;ldquo;About&amp;rdquo;
ersetzt. Diese Änderung muss dann ebenfalls committed werden.&lt;/p&gt;
&lt;h3 id=&#34;branches-mergen&#34;&gt;Branches mergen&lt;/h3&gt;
&lt;p&gt;Bis jetzt wurden einige Arbeiten am Repository durchgeführt. Dieser
Abschnitt soll noch kurz zusammenfassen, was alles geschah.
Zunächst wurden zwei neue Branches mit den Namen &amp;ldquo;content&amp;rdquo; und &amp;ldquo;menu&amp;rdquo;
erstellt. Beide basieren auf den Branch &amp;ldquo;master&amp;rdquo;. Im Anschluss wurde dann
ein Commit in &amp;ldquo;content&amp;rdquo; und zwei Commits in &amp;ldquo;menu&amp;rdquo; erzeugt.&lt;/p&gt;
&lt;p&gt;Diese Änderungen können nun zusammengeführt werden. Dafür existiert
der Befehl &amp;ldquo;git merge&amp;rdquo;. Dieser Befehl muss dort ausgeführt werden, wohin
die Änderungen aus dem anderen Branch eingefügt werden sollen.
In diesem Beispiel sollen die Änderungen aus den Branches &amp;ldquo;content&amp;rdquo; und &amp;ldquo;menu&amp;rdquo;
in &amp;ldquo;master&amp;rdquo; übernommen werden. Dazu muss man auf
den Branch &amp;ldquo;master&amp;rdquo; wechseln:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend kann der erste Branch gemerged werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git merge menu
Aktualisiere 24e65af..c3cf413
Fast-forward
index.html | 10 ++++++++++
1 file changed, 10 insertions(+)
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-merge.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Nach dem Merge sind die beiden Branches &#39;menu&#39; und &#39;master&#39; identisch.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-merge.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Git führt hier ein sogenannten „Fast-forward“ merge durch. Dies
geschieht immer genau dann, wenn seit dem Abzweigen
des Branches auf dem ursprünglichen Branch keine
Änderungen geschehen sind. Das ist genau
bei diesem Merge der Fall. Anders sieht es hingegen aus, wenn man den
Branch &amp;ldquo;content&amp;rdquo; nach &amp;ldquo;master&amp;rdquo; mergen möchte.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git merge content
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl öffnet den in Git konfigurierten Editor, etwa vim, mit folgendem
Inhalt:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;Merge branch &#39;content&#39;

# Bitte geben Sie eine Commit-Beschreibung ein um zu erklären, warum dieser
# Merge erforderlich ist, insbesondere wenn es einen aktualisierten
# Upstream-Branch mit einem Thema-Branch zusammenführt.
#
# Zeilen beginnend mit &#39;#&#39; werden ignoriert, und eine leere Beschreibung
# bricht den Commit ab.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;In der Regel belässt man den Commit-Text bei dem vorgegebenen Inhalt. Gegebenenfalls
kann man allerdings, wie die Nachricht bereits aussagt, einen Grund
angeben, warum der Merge nötig war. Als Ausgabe erscheint nach
dem Abspeichern dann folgendes:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;automatischer Merge von index.html
Merge made by the &#39;recursive&#39; strategy.
index.html | 3 +++
1 file changed, 3 insertions(+)
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-merge2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Der Recursive-Merge benötigt einen Merge-Commit.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-merge2.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Im Gegensatz zum ersten Merge war hier ein &amp;ldquo;recursive&amp;rdquo; Merge notwendig.
Dies geschieht zwar in diesem Fall auch vollkommen automatisch, die
Commit-Historie sieht allerdings anders aus. Dies hängt damit zusammen,
dass durch das Mergen vom Branch &amp;ldquo;menu&amp;rdquo;, nun Änderungen auf dem Branch
&amp;ldquo;master&amp;rdquo; passiert sind, seitdem der Branch &amp;ldquo;content&amp;rdquo; abgezweigt wurde.
Die beiden Branches sind dadurch divergiert. Das heißt,
die beiden Commits auf dem Branch &amp;ldquo;content&amp;rdquo; fußen nicht direkt auf dem
neuen Commit aus &amp;ldquo;content&amp;rdquo;, welches in &amp;ldquo;master&amp;rdquo; überführt worden ist.&lt;/p&gt;
&lt;p&gt;Wenn man nun das Git Log anschaut, dann sind mittlerweile alle Commits
aus allen Branches in &amp;ldquo;master&amp;rdquo; enthalten. Zusätzlich wurde durch
den letzten Merge ein weiterer Merge-Commit hinzugefügt.&lt;/p&gt;
&lt;h4 id=&#34;merge-konflikte&#34;&gt;Merge-Konflikte&lt;/h4&gt;
&lt;p&gt;Mergen von Branches ist nicht immer ganz einfach. Git selbst verfolgt
verschiedenen Strategien, um Branches zu mergen. Das klappt
bei einigen kleineren Änderungen zwar ohne Probleme, wenn
allerdings größere Änderungen in den Branches stattgefunden haben,
passiert es häufig, dass dann Merge-Konflikte auftreten. Merge-Konflikte
sind Probleme, die auftreten, wenn der gleiche Code-Abschnitt von beiden
Branches verändert wurde. Darunter fällt auch, wenn Zeilen auf
einem Branch gelöscht worden sind, aber auf dem anderen noch vorhanden
sind.&lt;/p&gt;
&lt;p&gt;Das Verhalten lässt sich auch ganz einfach nachbilden. Zunächst wechselt
man zurück auf den Branch &amp;ldquo;master&amp;rdquo;, falls man sich noch nicht drauf
befindet.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout master
Bereits auf &#39;master&#39;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend erzeugt man einen neuen Branch:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout -b titel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Auf diesem Branch ändert man anschließend den Titel in der &amp;lt;h1&amp;gt;-Überschrift
von &amp;ldquo;Hallo Git!&amp;rdquo; in &amp;ldquo;Hallo Merge-Konflikt!&amp;rdquo;. Nachdem abspeichern, kann man die Datei
wieder wie gewohnt zum Index hinzufügen und schlussendlich committen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Titel für den Merge-Konflikt&amp;quot;
[titel 420e0ae] Titel für den Merge-Konflikt
1 file changed, 1 insertion(+), 1 deletion(-)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Anschließend geht es zurück auf &amp;ldquo;master&amp;rdquo;.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git checkout master
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Dort ändert man den Titel in der &amp;lt;h1&amp;gt;-Überschrift von &amp;ldquo;Hallo Git!&amp;rdquo;
auf &amp;ldquo;Hallo!&amp;rdquo;. Auch hier committed man die Änderungen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Neuer Titel&amp;quot;
[master 9cb085b] Neuer Titel
1 file changed, 1 insertion(+), 1 deletion(-)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Die Voraussetzung für einen simplen Merge-Konflikt wurden somit geschaffen.
Wenn man nun die beiden Branches &amp;ldquo;master&amp;rdquo; und &amp;ldquo;titel&amp;rdquo; mergen möchte,
geschieht folgendes:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git merge titel
automatischer Merge von index.html
KONFLIKT (Inhalt): Merge-Konflikt in index.html
Automatischer Merge fehlgeschlagen; beheben Sie die Konflikte und committen Sie dann das Ergebnis.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie gewünscht, trat der Merge-Konflikt auf. Bevor man hingeht und den Konflikt
behebt, lohnt sich ein Blick auf die Ausgabe von &amp;ldquo;git status&amp;rdquo;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master
Sie haben nicht zusammengeführte Pfade.
(beheben Sie die Konflikte und führen Sie &amp;quot;git commit&amp;quot; aus)

Nicht zusammengeführte Pfade:
  (benutzen Sie &amp;quot;git add/rm &amp;lt;Datei&amp;gt;...&amp;quot; um die Auflösung zu markieren)

    von beiden geändert:    index.html

keine Änderungen zum Commit vorgemerkt (benutzen Sie &amp;quot;git add&amp;quot; und/oder &amp;quot;git commit -a&amp;quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl &amp;ldquo;git status&amp;rdquo; gibt bei fehlgeschlagenen automatischen Merges
immer die Information aus, dass Dateien vorhanden sind, die noch zusammengeführt
werden müssen.&lt;/p&gt;
&lt;p&gt;Schaut man sich nun die Datei &amp;ldquo;index.html&amp;rdquo; an, dann findet man dort folgende Zeilen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;&amp;lt;&amp;lt;&amp;lt;&amp;lt;&amp;lt;&amp;lt; HEAD
&amp;lt;h1&amp;gt;Hallo!&amp;lt;/h1&amp;gt;
=======
&amp;lt;h1&amp;gt;Hallo Merge-Konflikt!&amp;lt;/h1&amp;gt;
&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt;&amp;gt; titel
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Merge-Konflikt wird direkt in der Quell-Datei eingefügt. Git nutzt
Marker um aufzuzeigen, welcher Teil des Codes aus welchem Branch bzw. Commit
kommt. In der ersten Zeile des Konflikt ist der Marker folgender: &amp;ldquo;&amp;laquo;&amp;laquo;&amp;laquo;&amp;lt; HEAD&amp;rdquo;.
HEAD ist jeweils ein Zeiger auf den aktuellen Commit auf dem Branch, auf dem man sich
vor dem Merge befand. HEAD gibt es nicht nur bei Merge-Konflikten, sondern auch
an allen anderen Stellen in einem Git-Repository. In diesem Fall ist das der letzte Commit im Branch &amp;ldquo;master&amp;rdquo;.
Getrennt wird dies durch den weiteren Marker &amp;ldquo;=======&amp;rdquo;. Alles was zwischen
&amp;ldquo;&amp;laquo;&amp;laquo;&amp;laquo;&amp;lt; HEAD&amp;rdquo; und &amp;ldquo;=======&amp;rdquo; befindet, stammt vom aktuellen Branch ab, in diesem Fall also &amp;ldquo;master&amp;rdquo;.
Der zweite Teil nutzt ebenfalls das &amp;ldquo;=======&amp;rdquo; als Trennzeichen und endet mit &amp;ldquo;&amp;raquo;&amp;raquo;&amp;raquo;&amp;gt; titel&amp;rdquo;.
In diesem Teil sind dann alle Änderungen aus dem Branch &amp;ldquo;titel&amp;rdquo; enthalten.&lt;/p&gt;
&lt;p&gt;Der Konflikt kann nun relativ einfach aufgelöst werden. Es müssen alle Marker
entfernt und nur der gewünschte Teil eingefügt werden. In diesem Falle
ist gewollt die Änderungen aus dem HEAD beizubehalten, weshalb man Zeile 1
und Zeile 3-5 löschen kann. Im Anschluss muss man &amp;ldquo;index.html&amp;rdquo; wieder dem
Index hinzufügen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man nun erneut &amp;ldquo;git status&amp;rdquo; ausführt, dann meldet Git, dass die Konflikte
behoben worden sind.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master
Alle Konflikte sind behoben, aber Sie sind immer noch beim Merge.
  (benutzen Sie &amp;quot;git commit&amp;quot; um den Merge abzuschließen)

nichts zu committen, Arbeitsverzeichnis unverändert
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Beim darauffolgenden Ausführen von &amp;ldquo;git commit&amp;rdquo; öffnet sich erneut der
Editor mit folgender Commit-Nachricht:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git commit
Merge branch &#39;titel&#39;

Conflicts:
    index.html
#
# Es sieht so aus, als committen Sie einen Merge.
# Falls das nicht korrekt ist, löschen Sie bitte die Datei
#       .git/MERGE_HEAD
# und versuchen Sie es erneut.
#
# Bitte geben Sie eine Commit-Beschreibung für Ihre Änderungen ein. Zeilen,
# die mit &#39;#&#39; beginnen, werden ignoriert, und eine leere Beschreibung
# bricht den Commit ab.
# Auf Branch master
# Alle Konflikte sind behoben, aber Sie sind immer noch beim Merge.
&lt;/code&gt;&lt;/pre&gt;
&lt;a href=&#34;https://svij.org/graphics/git2-branch-merge3.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Der Graph vom Repository nach dem letzten Merge..&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/git2-branch-merge3.webp&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Hier kann man, wenn gewünscht, die Commit-Nachricht des Merges verändern.
Nachdem dies erledigt ist, ist auch der Merge-Konflikt erfolgreich behoben.&lt;/p&gt;
&lt;p&gt;Zum Schluss können die nicht mehr benötigten Branches aufgeräumt werden.
Der Befehl &amp;ldquo;git branch&amp;rdquo; kennt hierfür den Parameter &amp;ldquo;-d&amp;rdquo; für &amp;ldquo;delete&amp;rdquo;:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git branch -d titel
Branch titel entfernt (war 420e0ae).
&lt;/code&gt;&lt;/pre&gt;
&lt;h3 id=&#34;ausblick&#34;&gt;Ausblick&lt;/h3&gt;
&lt;p&gt;Der nächste Teil rundet den Einstieg in die grundlegendsten Funktionen von Git ab.
Thematisiert wird zum einen wie man mit Remote-Repositories arbeitet und zum anderen wie
man Branches &amp;ldquo;rebased&amp;rdquo;.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/&#34;&gt;Hier geht es zu Teil 1&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2015/01/12/git-fur-einsteiger-teil-3/&#34;&gt;Hier geht es zu Teil 3&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Mozilla Stumbler ausprobiert</title>
      <link>https://svij.org/blog/2014/11/01/mozilla-stumbler-ausprobiert/</link>
      <pubDate>Sat, 01 Nov 2014 12:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/11/01/mozilla-stumbler-ausprobiert/</guid>
      <description>&lt;p&gt;Vorgestern bin ich bei Golem über den Artikel &lt;a href=&#34;http://www.golem.de/news/stumbler-herumstolpern-fuer-mozillas-geolokationsdienst-1410-110203.html&#34;&gt;über Mozilla Stumbler&lt;/a&gt;
gestolpert. Die App für Android hatte ich vor etwa einem Jahr mal kurz angetestet, doch
ergab sich hier wieder die Gelegenheit es mal erneut auszuprobieren.&lt;/p&gt;
&lt;h3 id=&#34;was-ist-es&#34;&gt;Was ist es?&lt;/h3&gt;
&lt;p&gt;Mit Mozilla Stumbler möchte Mozilla einen freien Geolokationsdienst erschaffen, der mit den diversen
kommerziellen Angeboten konkurrieren kann. Der bekannteste Vertreter unfreier Gelokationsdienste ist
wohl Google. Erfasst werden dabei nicht nur die GPS-Position, sondern vor allem auch die an dem Ort
verfügbaren WLAN-Netze und Mobilfunk-Zellen. Sinn der Sache ist, dass man auch ohne einem verfügbaren GPS-Signal
möglichst genau geortet werden kann, etwa in geschlossenen Gebäuden. Dies funktioniert unter Android
beispielsweise mit den Google-Diensten gut und schnell. Diese Art der Ortung wird &lt;a href=&#34;https://de.wikipedia.org/wiki/Assisted_Global_Positioning_System&#34;&gt;Assisted GPS&lt;/a&gt;
genannt.&lt;/p&gt;
&lt;p&gt;Mozillas Dienst nennt sich schlicht &lt;a href=&#34;https://location.services.mozilla.com/&#34;&gt;„Mozilla Location Service“&lt;/a&gt;.
Alle Daten stehen unter &lt;a href=&#34;https://creativecommons.org/publicdomain/zero/1.0/&#34;&gt;Public Domain&lt;/a&gt; und können
&lt;a href=&#34;https://location.services.mozilla.com/downloads&#34;&gt;heruntergeladen&lt;/a&gt; werden.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;[Update]&lt;/strong&gt;&lt;/p&gt;
&lt;p&gt;Korrektur: Es stehen nicht alle Daten unter Public Domain. Ganz im Gegenteil: Es werden
lediglich die Positionsdaten vom Mobilfunk freigegeben. WLAN-Positionsdaten werden &lt;em&gt;nicht&lt;/em&gt; herausgegeben,
da es hier anscheinend Probleme bezüglich des Datenschutzes gibt. Nähere Informationen hierzu finden
sich &lt;a href=&#34;https://github.com/mozilla/ichnaea/issues/330&#34;&gt;in einem GitHub-Issue&lt;/a&gt; und &lt;a href=&#34;https://news.ycombinator.com/item?id=8525635&#34;&gt;hier&lt;/a&gt;.
Das ganze trübt leider den Service, da er so nun nicht wirklich frei ist, aber es als frei beworben wird.&lt;/p&gt;
&lt;p&gt;Danke an Matthias (per E-Mail) und &lt;a href=&#34;https://twitter.com/kamikazow/status/528732600291323904&#34;&gt;Markus&lt;/a&gt; für die Hinweise.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;[/Update]&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;wie-funktioniert-es&#34;&gt;Wie funktioniert es?&lt;/h3&gt;
&lt;p&gt;Das Mitmachen ist sehr einfach. Am einfachsten geht es, wenn man die Android App &lt;a href=&#34;https://play.google.com/store/apps/details?id=org.mozilla.mozstumbler&#34;&gt;„Mozilla Stumbler“&lt;/a&gt;
aus dem Google Play Store installiert. Danach muss man lediglich die App starten und an die frische
Luft und loslaufen.&lt;/p&gt;
&lt;a href=&#34;https://svij.org/graphics/mozstumbler1.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Mozilla Stumbler im ersten Lauf.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/mozstumbler1.webp&#34; width=&#34;250&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;a href=&#34;https://svij.org/graphics/mozstumbler2.webp&#34; data-lightbox=&#34;image&#34; data-title=&#34;Die erfassten Daten werden dargestellt.&#34;&gt;
	&lt;img src=&#34;https://svij.org/graphics/mozstumbler2.webp&#34; width=&#34;250&#34; style=&#34;margin:20px;&#34;&gt;
&lt;/a&gt;
&lt;p&gt;Ich hab die App in der Dortmunder Innenstadt mal ausprobiert. Wie man am ersten (linken) Screenshot
sieht, waren zu dem Zeitpunkt einige Teile der Innenstadt noch nicht erfasst. Erfasste
Gegenden werden mit hellblauen Punkten übermalt. Wenn man los läuft, dann erfasst die App in regelmäßigen
Abständen die verfügbaren WLAN-Netze und Mobilfunk-Zellen. In meinem Fall wurden innerhalb von 15 Minuten
knapp 40 Berichte angefertigt. Interessanterweise fand die App während des Spaziergangs
knapp &lt;em&gt;900&lt;/em&gt;(!) WLAN-Netze.&lt;/p&gt;
&lt;p&gt;Die &lt;a href=&#34;https://location.services.mozilla.com/map#2/15.0/10.0&#34;&gt;Map&lt;/a&gt; wird einmal am Tag aktualisiert.
Meine erfassten Daten wurden am darauffolgenden Tag auch direkt in der Map angezeigt (siehe Screenshot 2).&lt;/p&gt;
&lt;p&gt;Interessant ist auch, dass es ein kleines &lt;a href=&#34;https://location.services.mozilla.com/leaders&#34;&gt;„Leaderboard“&lt;/a&gt;
gibt. Innerhalb der App kann man seinen Namen eintragen, um anschließend dort gelistet zu werden.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Wer mit einfachen Möglichkeiten an dem Projekt teilnehmen möchte, der kann sich recht einfach
die App installieren und los legen. Für den dauerhaften Betrieb ist es wohl eher nicht geeignet,
außer man kann damit leben, dass der Akku sich schneller leert. Ich finde das Projekt unterstützenswert,
da man hier einen offenen Dienst sehr einfach unterstützen kann der nicht von einer kommerziellen Firma
geführt wird. Für den praktischen Einsatz ist es insbesondere für Firefox OS und auch anderen freien
Systemen und Apps relevant.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Git für Einsteiger - Teil 1</title>
      <link>https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/</link>
      <pubDate>Sat, 25 Oct 2014 12:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/10/25/git-fur-einsteiger-teil-1/</guid>
      <description>&lt;p&gt;Zur Entwicklung von Software wird in der Regel ein Versionsverwaltungsprogramm
genutzt. Es gibt zahlreiche Anwendungen um dies zu erledigen, zu den bekannteren Programmen
gehören Subversion, CVS, Mercurial, Bazaar und eben Git. Dieses mehrteilige
Tutorium soll den Einstieg in die Nutzung von Git erläutern.&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Dieses Tutorium besteht aus vier Teilen. Wem das Tutorium gefällt und mehr über
Git lernen möchte, der kann sich das Buch &lt;a href=&#34;https://amzn.to/3q0A5Iu&#34;&gt;„Versionsverwaltung mit Git“&lt;/a&gt;
für 29,99€ bestellen. In diesem Buch, was ich geschrieben habe, werden die Themen rund um Git noch
deutlich ausführlicher behandelt.&lt;/strong&gt;&lt;/p&gt;
&lt;h3 id=&#34;was-ist-eine-versionsverwaltung&#34;&gt;Was ist eine Versionsverwaltung?&lt;/h3&gt;
&lt;p&gt;Für die Leser, die noch keine Erfahrung oder Ahnung von
Versionsverwaltungsprogrammen haben, ist es zunächst wichtig zu wissen, was denn
genau ein solches Programm macht. Die Bedeutung einer Versionsverwaltung lässt
sich schon fast aus dem Wort ableiten: Es handelt sich um das Verwalten von
Versionen. Konkret heißt dies, dass man von Dateien Versionen erzeugen kann, die
dann sinnvoll verwaltet werden können. Einzelne Versionen beinhalten keineswegs
nur große Änderungen, sondern sehr wohl auch kleinere Änderungen.&lt;/p&gt;
&lt;p&gt;Viele kennen es: Man geht einer Tätigkeit nach – sei es an einem
Text, einem Bild oder an einem Video – und man möchte den aktuellen Stand immer mal
wieder zwischenspeichern, damit man zum einen eine Sicherung der Datei hat und zum
anderen, damit man wieder auf eine ältere Version zurückspringen kann, etwa wenn etwas
falsch gelaufen ist. Jede Person
hat dabei verschiedene Ansätze die einzelnen Versionen irgendwo abzulegen. Die
eine Person fügt jeweils eine Versionsnummer in den Dateinamen ein, eine andere Person
macht sich wiederum einzelne Ordner für jede Version mit dem aktuellen Datum, in
dem die einzelnen Stände gesichert werden.&lt;/p&gt;
&lt;p&gt;Wirklich praktikabel und effizient sind keine der beiden genannten
Varianten, da sich sehr schnell und sehr einfach Fehler einschleichen, etwa
wenn man alte Revisionen löscht, die man gegebenenfalls hinterher doch wieder
braucht.&lt;/p&gt;
&lt;p&gt;Genau hier kommen Versionsverwaltungssysteme ins Spiel. Mit einer
Versionsverwaltung werden zu den reinen Veränderungen noch weitere Informationen
zu einer Version gespeichert. Darunter fallen
Informationen zum Autor, die Uhrzeit und eine Änderungsnotiz. Diese werden bei jedem
Versionswechsel gespeichert. Durch die gesammelten Dateien lässt sich
so schnell und einfach eine Änderungshistorie ansehen und verwalten. Falls
zwischendurch Fehler in den versionierten Dateien aufgetreten sind, kann man dann
wieder zurück zu einer Version springen, um von dort aus erneut weiter zu machen.
Dabei ist es ganz egal, um was für eine Art von Dateien es sich handelt. Am
häufigsten werden Versionsverwaltungsprogramme zur Software-Entwicklung
eingesetzt.&lt;/p&gt;
&lt;p&gt;Aber nicht nur für Programmierer ist eine Versionsverwaltung
sinnvoll, sondern auch, wie bereits geschrieben, kann der Einsatz für Grafiker oder Autoren durchaus
nützlich sein. Ein Grafiker könnte sich so Versionen von bearbeiteten Bildern
speichern, um bei misslungenen Änderungen wieder zurück springen zu können. Bei
Autoren geht es um Text, der ähnlich zum Quellcode von Software-Projekten,
gut verwaltet werden kann.&lt;/p&gt;
&lt;p&gt;Es gibt drei verschiedene Konzepte zur Versionsverwaltung: die lokale, zentrale
und die verteilte Versionsverwaltung.&lt;/p&gt;
&lt;h4 id=&#34;lokale-versionsverwaltung&#34;&gt;Lokale Versionsverwaltung&lt;/h4&gt;
&lt;p&gt;Die lokale Versionsverwaltung ist wohl selten in produktiven Umgebungen
zu finden, da sie lediglich lokal arbeiten und häufig nur einzelne Dateien
versionieren. Die oben bereits erwähnte manuelle
Erzeugen von Versionen von Dateien wäre zum Beispiel eine lokale
Versionsverwaltung mit einer einzelnen Datei. Es ist zwar ziemlich einfach zu
nutzen, allerdings resultiert daraus eine hohe Fehleranfälligkeit und sie ist
zudem wenig flexibel. Echte Versionsverwaltungssoftware gibt es mit &lt;a href=&#34;https://de.wikipedia.org/wiki/SCCS&#34;&gt;SCCS&lt;/a&gt;
und &lt;a href=&#34;https://de.wikipedia.org/wiki/Revision_Control_System&#34;&gt;RCS&lt;/a&gt; auch.
Der wohl größte Minuspunkt von lokaler Versionsverwaltung ist, dass man
nicht im Standard mit mehreren Personen an Dateien arbeiten kann. Zudem besteht
keinerlei Datensicherheit, da die Daten nicht zusätzlich auf einem entfernten
Server liegen, sofern nicht zusätzliche Backups durchgeführt werden.&lt;/p&gt;
&lt;h4 id=&#34;zentrale-versionsverwaltung&#34;&gt;Zentrale Versionsverwaltung&lt;/h4&gt;
&lt;p&gt;Eine zentrale Versionsverwaltung ist hingegen häufig in produktiven Umgebungen
zu finden. &lt;a href=&#34;https://de.wikipedia.org/wiki/Subversion&#34;&gt;Subversion&lt;/a&gt;
und &lt;a href=&#34;https://de.wikipedia.org/wiki/Concurrent_Versions_System&#34;&gt;CVS&lt;/a&gt;
sind beispielsweise
Vertreter der zentralen Versionsverwaltung. Hauptmerkmal ist, dass das
Repository lediglich auf einem zentralen Server liegt. „Repository“ ist ein
englisches Wort für „Lager“, „Depot“ oder „Quelle“. Ein Repository ist somit
ein Lager, in dem die Daten liegen. Autorisierte Nutzer eines
Repositorys arbeiten dabei lokal mit einer Arbeitskopie der im Repository
vorhandenen Dateien. Die Logik der Versionsverwaltung liegt dabei auf dem
zentralen Server. Wenn man also auf eine andere Revision wechseln möchte oder
sich die Revisionsänderungen anschauen möchte, werden stets die Daten vom Server
heruntergeladen.&lt;/p&gt;
&lt;h4 id=&#34;verteilte-versionsverwaltung&#34;&gt;Verteilte Versionsverwaltung&lt;/h4&gt;
&lt;p&gt;Zu den verteilten Versionsverwaltungssystemen gehört nicht nur &lt;a href=&#34;http://git-scm.com/&#34;&gt;Git&lt;/a&gt;,
sondern unter anderem auch &lt;a href=&#34;http://bazaar.canonical.com/en/&#34;&gt;Bazaar&lt;/a&gt; oder
&lt;a href=&#34;http://mercurial.selenic.com/&#34;&gt;Mercurial&lt;/a&gt;. Im Gegensatz zur zentralen
Versionsverwaltung besitzt jeder Nutzer des Repositorys nicht nur eine
Arbeitskopie, sondern das komplette Repository. Wenn also zwischen verschiedenen
Revisionen gewechselt wird oder man sich die letzten Änderungen anschauen möchte,
muss nur einmal das Repository „geklont“ werden. Danach stehen alle
Funktionalitäten der Versionsverwaltung offline zur Verfügung. Dadurch wird
nicht nur unnötiger Netzwerktraffic vermieden, sondern auch die Geschwindigkeit
wird, durch den fehlenden Netzwerk-Overhead, deutlich erhöht.
Zusätzlich besitzen verteilte Versionswaltungssysteme eine höhere Datensicherheit,
da die Daten des Repositorys in der Regel auf vielen Rechnern verteilt liegen.&lt;/p&gt;
&lt;h3 id=&#34;geschichtliches&#34;&gt;Geschichtliches&lt;/h3&gt;
&lt;p&gt;Lange Zeit nutzten die Entwickler vom Linux-Kernel das proprietäre
Versionsverwaltungssystem &lt;a href=&#34;http://www.bitkeeper.com/&#34;&gt;BitKeeper&lt;/a&gt;. Nach einer
Lizenzänderung seitens der Herstellerfirma von BitKeeper, konnte das Team
um den Linux-Kernel, allen vorran Linus Torvalds, BitKeeper nicht mehr
kostenfrei verwenden, weswegen Linus Torvalds mit der Entwicklung von Git begann.&lt;/p&gt;
&lt;p&gt;Da die Entwicklung im Jahr 2005 begann, gehört Git zu den jüngsten
Versionsverwaltungssystemen. Für Linus Torvalds war es wichtig, dass das
künftige Versionsverwaltungssystem drei spezielle Eigenschaften besitzt. Dazu
gehörten zum einen Arbeitsabläufe, die an BitKeeper angelehnt sind, Sicherheit
gegen böswillige und unbeabsichtigte Verfälschung des Repositorys, sowie eine
hohe Effizienz. Das Projekt &lt;a href=&#34;http://www.monotone.ca/&#34;&gt;„Monotone“&lt;/a&gt;, ebenfalls
ein Versionsverwaltungssystem, wäre fast perfekt gewesen. Es fehlte
lediglich die Effizienz. Mit Git erschuf Linus Torvalds dann doch eine
eigene Versionsverwaltung, die nicht auf den Quellen von Monotone oder BitKeeper
beruht.&lt;/p&gt;
&lt;p&gt;Interessant ist auch die Namensnennung von Git. Git ist das englische Wort
für „Blödmann“. Linus Torvalds selbst sagte spaßeshalber: „I&amp;rsquo;m an egoistical
bastard, and I name all my projects after myself. First &amp;lsquo;Linux&amp;rsquo;, now &amp;lsquo;Git&amp;rsquo;.“
(Deutsch: „Ich bin ein egoistischer Bastard, und ich nenne alle meine Projekte
nach mir selbst, Erst &amp;lsquo;Linux&amp;rsquo; und nun &amp;lsquo;Git&amp;rsquo;.“). Natürlich gibt es auch richtige
Gründe, das Projekt „git“ zu nennen. Zum einen enthält das Wort lediglich drei
Buchstaben, was das Tippen auf der Tastatur erleichtert, zum anderen gab es kein
genutztes UNIX-Kommando, womit es kollidieren würde.&lt;/p&gt;
&lt;h3 id=&#34;git-repository-starten&#34;&gt;Git-Repository starten&lt;/h3&gt;
&lt;p&gt;Git bietet einige interessante Funktionen, die nach und nach in diesem Tutorium
vorgestellt werden. Zunächst muss man Git installieren. Die gängigen
Linux-Distributionen stellen Git in ihrer Paketverwaltung unter dem Paketnamen &amp;ldquo;git&amp;rdquo; bereit.
Für andere Plattformen bietet die Git-Projekthomepage einer &lt;a href=&#34;http://git-scm.com/downloads&#34;&gt;Download-Seite&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Um die Nutzung von Git sinnvoll zu erlernen, bietet es sich an die im Tutorium
angeführten Befehle ebenfalls auszuführen, um die Arbeitsweise vollständig
nachvollziehen kann. Damit dieses Tutorium einen sinnvollen Praxis-Bezug
hat, wird im Laufe der Zeit eine kleine statische Webseite mit dem HTML-Framework
&lt;a href=&#34;http://getbootstrap.com/&#34;&gt;„Bootstrap“&lt;/a&gt; gebaut.&lt;/p&gt;
&lt;p&gt;Zu Beginn muss man zunächst ein leeres Projektverzeichnis anlegen, in dem
im Anschluss die Projekt-Dateien gespeichert werden. Dazu legt man zuerst den
Ordner &amp;ldquo;Webseite-mit-Git&amp;rdquo; an und wechselt dort hinein.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ mkdir Webseite-mit-Git
$ cd Webseite-mit-Git
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Jetzt kann man mit dem folgendem Befehl ein Git-Repository anlegen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git init
Initialisierte leeres Git-Repository in /home/sujee/Webseite-mit-Git/.git/ 
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Mit diesem Befehl erzeugt Git also ein leeres Repository im Projektordner.
Dazu legt Git, wie es die Ausgabe bereits mitteilt, ein Unterverzeichnis &amp;ldquo;.git&amp;rdquo;
im Projektverzeichnis an.&lt;/p&gt;
&lt;p&gt;In diesem Ordner werden noch einige weitere Unterverzeichnisse angelegt, die
man mit dem Befehl &amp;ldquo;ls -l .git&amp;rdquo; einsehen kann.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ ls -l .git 
insgesamt 32
drwxr-xr-x 2 sujee sujee 4096 20. Jul 16:41 branches
-rw-r--r-- 1 sujee sujee   92 20. Jul 16:41 config
-rw-r--r-- 1 sujee sujee   73 20. Jul 16:41 description
-rw-r--r-- 1 sujee sujee   23 20. Jul 16:41 HEAD
drwxr-xr-x 2 sujee sujee 4096 20. Jul 16:41 hooks
drwxr-xr-x 2 sujee sujee 4096 20. Jul 16:41 info
drwxr-xr-x 4 sujee sujee 4096 20. Jul 16:41 objects
drwxr-xr-x 4 sujee sujee 4096 20. Jul 16:41 refs
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie man sieht, erzeugt Git einige Verzeichnisse und dort werden auch
Daten speichert. Das &amp;ldquo;.git&amp;rdquo;-Verzeichnis ist das einzige Verzeichnis in dem Git
die Informationen des Repositorys speichert. Daher sollte man dieses Verzeichnis keinesfalls
löschen, da man sonst alle Daten des Repositorys verliert, insbesondere alle
Revisionen. Da zu diesem Zeitpunkt in dem Beispielrepository keinerlei
Operationen mit Git durchgeführt worden sind, wäre das in diesem Beispiel
natürlich nicht sonderlich tragisch. Man sollte allerdings die Dateien
nur anfassen, wenn man weiß was man tut.&lt;/p&gt;
&lt;h4 id=&#34;git-konfiguration&#34;&gt;Git Konfiguration&lt;/h4&gt;
&lt;p&gt;Da bereits ein leeres Repository angelegt worden ist, kann man ein Commit
hinzufügen. Was genau ein Commit ist, und wie man einen Commit tätigt, wird später
erläutert. Denn zunächst muss man noch seine Git-Installation konfigurieren.&lt;/p&gt;
&lt;p&gt;Vorerst werden allerdings nur zwei Dinge konfiguriert: Der eigene Entwicklername
und dessen E-Mail-Adresse.&lt;/p&gt;
&lt;p&gt;Mit dem folgenden Befehlen setzt man den eigenen Namen sowie die eigene
E-Mail-Adresse:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git config --global user.name &amp;quot;Sujeevan Vijayakumaran&amp;quot;
$ git config --global user.email mail@svij.org
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Mit diesen beiden Befehlen wird die Datei &amp;ldquo;~/.gitconfig&amp;rdquo; angelegt. Wenn man
in die Datei reinschaut steht folgendes darin:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;[user]
    name = Sujeevan Vijayakumaran
    email = mail@svij.org
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Mit &amp;ldquo;git config -l&amp;rdquo; lässt sich über die Kommandozeile die Konfiguration ebenfalls ansehen.&lt;/p&gt;
&lt;p&gt;Es muss beachtet werden, dass bei den oben genannten Befehlen die Git-Identität
global für den Benutzer gesetzt wird. Wenn man für einzelne Git-Repositorys
spezifische Einstellungen setzen will, dann reicht es, wenn man den Aufruf-Parameter
&amp;ldquo;&amp;ndash;global&amp;rdquo; weg lässt. Dies ist häufig dann sinnvoll, wenn man verschiedene
E-Mail-Adressen für verschiedene Projekte nutzt. Die angegebenen Informationen
zu einem Entwickler sind nämlich für alle Personen einsehbar, welche mindestens
Lese-Rechte im Repository besitzen, sofern der Entwickler mindestens ein
Commit getätigt hat.&lt;/p&gt;
&lt;h4 id=&#34;der-erste-commit&#34;&gt;Der erste Commit&lt;/h4&gt;
&lt;p&gt;Jetzt beginnt das echte Arbeiten mit dem Repository. Zu Beginn ist das Repository
leer, da keine Dateien vorhanden sind. Es müssen also zunächst einige Ordner
und/oder Dateien angelegt werden.&lt;/p&gt;
&lt;p&gt;Der Befehl &amp;ldquo;git status&amp;rdquo; zeigt den aktuellen Status des Repositorys an. Es gibt
noch keine Commits, weshalb Git meldet, dass es sich um die &amp;ldquo;Initiale Version&amp;rdquo; handelt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master

Initialer Commit

nichts zu committen (Erstellen/Kopieren Sie Dateien und benutzen Sie &amp;quot;git add&amp;quot; zum Beobachten)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Da keine Dateien in dem Projekt-Verzeichnis vorhanden sind, meldet Git, dass
nichts zu committen ist. Für das Beispiel-Projekt „Webseite mit Git“ muss
zuerst das HTML-Framework „Bootstrap“ heruntergeladen und anschließend entpackt
werden. Zum Schluss kann das ZIP-Paket wieder entfernt werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ wget https://github.com/twbs/bootstrap/releases/download/v3.2.0/bootstrap-3.2.0-dist.zip
$ unzip bootstrap-3.2.0-dist.zip
$ mv bootstrap-3.2.0-dist/* .
$ rmdir bootstrap-3.2.0-dist &amp;amp;&amp;amp; rm bootstrap-3.2.0-dist.zip
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Einige der oben aufgeführten Befehle geben Text auf der Standard-Ausgabe aus,
welcher hier aus Gründen der Übersichtlichkeit weggelassen worden ist.&lt;/p&gt;
&lt;p&gt;Nachdem die Dateien im Projekt-Verzeichnis gelandet sind, bietet es sich an
noch einmal &amp;ldquo;git status&amp;rdquo; auszuführen.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master

Initialer Commit

Unbeobachtete Dateien:
  (benutzen Sie &amp;quot;git add &amp;lt;Datei&amp;gt;...&amp;quot; um die Änderungen zum Commit vorzumerken)

  css/
  fonts/
  js/

nichts zum Commit vorgemerkt, aber es gibt unbeobachtete Dateien (benutzen Sie &amp;quot;git add&amp;quot; zum Beobachten)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wie man sieht, zeigt Git an, dass unbeobachtete Dateien vorhanden sind.
Unbeobachtete Dateien sind Dateien, die nicht von Git verwaltet werden und für
Git somit unbekannt sind. Mit dem Befehl &amp;ldquo;git add&amp;rdquo; kann man Dateien und Ordner
zu dem Staging Bereich hinzufügen. Der Staging Bereich ist der Bereich, in dem
die Dateien hinzugefügt werden, um diese für einen Commit vorzumerken.&lt;/p&gt;
&lt;p&gt;Zunächst wird nur der Ordner &amp;ldquo;css&amp;rdquo; hinzugefügt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add css/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Eine Ausgabe erfolgt bei erfolreicher Ausführung nicht. Ein erneutes Ausführen
von &amp;ldquo;git status&amp;rdquo; gibt folgendes aus:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master

Initialer Commit

zum Commit vorgemerkte Änderungen:
  (benutzen Sie &amp;quot;git rm --cached &amp;lt;Datei&amp;gt;...&amp;quot; zum Entfernen aus der Staging-Area)

  neue Datei:     css/bootstrap-theme.css
  neue Datei:     css/bootstrap-theme.css.map
  neue Datei:     css/bootstrap-theme.min.css
  neue Datei:     css/bootstrap.css
  neue Datei:     css/bootstrap.css.map
  neue Datei:     css/bootstrap.min.css
					      
Unbeobachtete Dateien:
  (benutzen Sie &amp;quot;git add &amp;lt;Datei&amp;gt;...&amp;quot; um die Änderungen zum Commit vorzumerken)

  fonts/
  js/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Durch das Hinzufügen des Ordners &amp;ldquo;css&amp;rdquo;, werden die einzelnen Dateien des Ordners
für den nächsten Commit vorgemerkt. Wenn man nicht den ganzen Ordner, sondern nur einzelne
Dateien hinzufügen möchte, geht das natürlich auch:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add fonts/glyphicons-halflings-regular.eot
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Es bietet sich anschließend noch einmal an &amp;ldquo;git status&amp;rdquo; auszuführen:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master

Initialer Commit

zum Commit vorgemerkte Änderungen:
  (benutzen Sie &amp;quot;git rm --cached &amp;lt;Datei&amp;gt;...&amp;quot; zum Entfernen aus der Staging-Area)

    neue Datei:     css/bootstrap-theme.css
    neue Datei:     css/bootstrap-theme.css.map
    neue Datei:     css/bootstrap-theme.min.css
    neue Datei:     css/bootstrap.css
    neue Datei:     css/bootstrap.css.map
    neue Datei:     css/bootstrap.min.css
    neue Datei:     fonts/glyphicons-halflings-regular.eot

Unbeobachtete Dateien:
  (benutzen Sie &amp;quot;git add &amp;lt;Datei&amp;gt;...&amp;quot; um die Änderungen zum Commit vorzumerken)

    fonts/glyphicons-halflings-regular.svg
    fonts/glyphicons-halflings-regular.ttf
    fonts/glyphicons-halflings-regular.woff
    js/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Vorher wurde das komplette &amp;ldquo;css&amp;rdquo;-Verzeichnis hinzugefügt. Mit dem Hinzufügen
einer einzelnen Datei, wird nicht mehr der Ordner allgemein von &amp;ldquo;git status&amp;rdquo;
gelistet, sondern es werden dann explizit alle einzelnen Dateien
aufgelistet.&lt;/p&gt;
&lt;p&gt;Diesmal werden alle restlichen Dateien, die noch nicht beobachtet werden hinzufügt:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add fonts/ js/
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Alternativ kann man auch den Befehl &amp;ldquo;git add -A&amp;rdquo; ausführen, um generell alle
unbeobachtete Dateien hinzuzufügen. Eine Ausgabe erscheint bei erfolgreicher
Ausführung nicht. Aber Achtung: Dies sollte man nur tun, wenn man sicher ist,
dass sonst keine weiteren temporären Dateien vorhanden sind, die nicht in dem
Commit landen sollen.&lt;/p&gt;
&lt;p&gt;Falls doch Dateien ausversehen zum Staging Bereich hinzugefügt worden sind,
kann man sie ganz leicht mit &amp;ldquo;git rm &amp;ndash;cached &lt;Datei&gt;&amp;rdquo; wieder entfernen.&lt;/p&gt;
&lt;p&gt;Nach einem erneuten ausführen von &amp;ldquo;git status&amp;rdquo; werden alle hinzugefügte Dateien aus
den drei Unterordnern aufgelistet. Es bietet es sich nicht nur für Anfänger an jedes Mal vor
einem Commit die hinzugefügten Dateien mittels &amp;ldquo;git status&amp;rdquo; zu überprüfen, um
zu vermeiden, dass nicht ungewollte Dateien in das Repository eingetragen werden.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master

Initialer Commit

zum Commit vorgemerkte Änderungen:
  (benutzen Sie &amp;quot;git rm --cached &amp;lt;Datei&amp;gt;...&amp;quot; zum Entfernen aus der Staging-Area)

  neue Datei:     css/bootstrap-theme.css
  neue Datei:     css/bootstrap-theme.css.map
  neue Datei:     css/bootstrap-theme.min.css
  neue Datei:     css/bootstrap.css
  neue Datei:     css/bootstrap.css.map
  neue Datei:     css/bootstrap.min.css
  neue Datei:     fonts/glyphicons-halflings-regular.eot
  neue Datei:     fonts/glyphicons-halflings-regular.svg
  neue Datei:     fonts/glyphicons-halflings-regular.ttf
  neue Datei:     fonts/glyphicons-halflings-regular.woff
  neue Datei:     js/bootstrap.js
  neue Datei:     js/bootstrap.min.js
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn alle Dateien korrekt mit &amp;ldquo;git add&amp;rdquo; eingetragen worden sind, kann man
den ersten Commit tätigen. Der Commit enthält dabei dann eben genau die Dateien,
die man mit &amp;ldquo;git add&amp;rdquo; zum Staging Bereich hinzugefügt hat. Dateien, die man
eventuell ausgelassen hat, bleiben unangetastet.&lt;/p&gt;
&lt;p&gt;Mit dem folgenden Befehl wird der erste Commit erzeugt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git commit -m &amp;quot;Bootstrap hinzugefügt.&amp;quot;
[master (Basis-Commit) 7f1c942] Bootstrap hinzugefügt.
12 files changed, 9006 insertions(+)
create mode 100644 css/bootstrap-theme.css
create mode 100644 css/bootstrap-theme.css.map
create mode 100644 css/bootstrap-theme.min.css
create mode 100644 css/bootstrap.css
create mode 100644 css/bootstrap.css.map
create mode 100644 css/bootstrap.min.css
create mode 100644 fonts/glyphicons-halflings-regular.eot
create mode 100644 fonts/glyphicons-halflings-regular.svg
create mode 100644 fonts/glyphicons-halflings-regular.ttf
create mode 100644 fonts/glyphicons-halflings-regular.woff
create mode 100644 js/bootstrap.js
create mode 100644 js/bootstrap.min.js
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der Befehl speichert erst in diesem Punkt den aktuellen Staging Bereich in einen
Commit. Mit dem Parameter &amp;ldquo;-m&amp;rdquo; kann eine Commit-Nachricht direkt übergeben werden,
diese fasst in der Regel die aktuellen Änderungen zusammen, sodass andere
Mitarbeiter in dem Repository die Änderungen in dem Commit schnell und einfach
nachvollziehen können. Man kann auch einen Commit erzeugen ohne den Parameter
&amp;ldquo;-m&amp;rdquo; anzugeben. Stattdessen öffnet sich der Standard-Editor des Systems
in dem man die Commit-Nachricht eintippen kann.&lt;/p&gt;
&lt;p&gt;Ein erneutes &amp;ldquo;git status&amp;rdquo; zeigt nach dem Commit erstmal keine Änderungen an.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
# Auf Zweig master
nichts einzutragen, Arbeitsverzeichnis sauber
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Der erste Commit ist also getätigt. Dieser wird häufig initialer Commit
oder Basis-Commit genannt, weil er der erste Commit des Repositorys ist,
auf welchem die anderen Commits aufbauen.&lt;/p&gt;
&lt;p&gt;Mit &amp;ldquo;git log&amp;rdquo; kann man die Historie des Repositorys anschauen. Bei lediglich einem
Commit ist es in diesem Fall natürlich sehr kurz.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git log
commit 7f1c942a8275fdeab84ebee61e6fe43a6d48e888
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Sun Jul 20 17:24:13 2014 +0200

Bootstrap hinzugefügt.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wichtig ist vor allem, dass jeder getätigte Commit eine eindeutige ID besitzt,
auf welche man sich beziehen kann, wenn dies benötigt wird. Dies kann unter
anderem dafür genutzt werden, um das Git Log zwischen zwei verschiedenen Revisionen
anzusehen oder auch um Änderungen eines speziellen Commits rückgängig zu machen.
Die ID ist eigentlich eine SHA-1 Checksumme, die aus den Änderungen erzeugt wird.
Weiterhin werden auch noch das Datum und der Autor im Commit vermerkt.&lt;/p&gt;
&lt;p&gt;Nachdem der erste Commit erledigt ist, kann die Arbeit also beginnen. Die Webseite,
die mit diesem Tutorium angelegt wird, braucht zunächst eine &amp;ldquo;index.html&amp;rdquo;-Datei
mit folgendem Inhalt:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;!DOCTYPE html&amp;gt;
&amp;lt;html lang=&amp;quot;en&amp;quot;&amp;gt;
  &amp;lt;head&amp;gt;
    &amp;lt;meta charset=&amp;quot;utf-8&amp;quot;&amp;gt;
    &amp;lt;meta http-equiv=&amp;quot;X-UA-Compatible&amp;quot; content=&amp;quot;IE=edge&amp;quot;&amp;gt;
    &amp;lt;meta name=&amp;quot;viewport&amp;quot; content=&amp;quot;width=device-width, initial-scale=1&amp;quot;&amp;gt;
    &amp;lt;title&amp;gt;Bootstrap 101 Template&amp;lt;/title&amp;gt;

    &amp;lt;!-- Bootstrap --&amp;gt;
    &amp;lt;link href=&amp;quot;css/bootstrap.min.css&amp;quot; rel=&amp;quot;stylesheet&amp;quot;&amp;gt;
  &amp;lt;/head&amp;gt;
  &amp;lt;body&amp;gt;
    &amp;lt;h1&amp;gt;Hello, world!&amp;lt;/h1&amp;gt;

    &amp;lt;!-- jQuery (necessary for Bootstrap&#39;s JavaScript plugins) --&amp;gt;
    &amp;lt;script src=&amp;quot;https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js&amp;quot;&amp;gt;&amp;lt;/script&amp;gt;
    &amp;lt;!-- Include all compiled plugins (below), or include individual files as needed --&amp;gt;
    &amp;lt;script src=&amp;quot;js/bootstrap.min.js&amp;quot;&amp;gt;&amp;lt;/script&amp;gt;
  &amp;lt;/body&amp;gt;
&amp;lt;/html&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Die Datei dient als Basis-Template für das HTML-Framework Bootstrap. Sie wird
zunächst nicht von Git beobachtet, da die Datei neu ist. Auch diese Datei muss
in das Repository committet werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;index.html hinzugefügt.&amp;quot;
[master 4cc7ce4] index.html hinzugefügt.
1 file changed, 21 insertions(+)
create mode 100644 index.html
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Hiermit wurde also der zweite Commit erzeugt. Der Befehl &amp;ldquo;git log&amp;rdquo; listet
beide auf:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git log

commit 4cc7ce45fb1a73d10325b465062d1ffa3435702f
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Sun Jul 20 17:37:51 2014 +0200

index.html hinzugefügt.

commit 7f1c942a8275fdeab84ebee61e6fe43a6d48e888
Author: Sujeevan Vijayakumaran &amp;lt;mail@svij.org&amp;gt;
Date:   Sun Jul 20 17:24:13 2014 +0200

Bootstrap hinzugefügt.
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Da das Grundgerüst der Webseite steht, kann man die Startseite &amp;ldquo;index.html&amp;rdquo;
nach seinem Belieben anpassen. Die Webseite braucht jetzt einen Titel im HTML-Head
und einen kleinen Inhalt im Body.&lt;/p&gt;
&lt;p&gt;Um den Titel zu verändern, reicht es Zeile 8 mit folgenden Inhalt zu überschreiben:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;title&amp;gt;Webseite mit Git&amp;lt;/title&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Statt der Überschrift &amp;ldquo;Hallo Welt&amp;rdquo;, wird in diesem Beispiel git gegrüßt:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;&amp;lt;h1&amp;gt;Hallo Git!&amp;lt;/h1&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Beide Dateien können jeweils mit einem Editor bearbeitet werden.
Nachdem man diese Änderungen durchgeführt hat,
kann man sich alle Änderungen mit &amp;ldquo;git diff&amp;rdquo; anschauen. Doch zunächst lohnt
sich mal wieder ein Blick auf die Ausgabe von &amp;ldquo;git status&amp;rdquo;.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git status
Auf Branch master
Änderungen, die nicht zum Commit vorgemerkt sind:
  (benutzen Sie &amp;quot;git add &amp;lt;Datei&amp;gt;...&amp;quot; um die Änderungen zum Commit vorzumerken)
  (benutzen Sie &amp;quot;git checkout -- &amp;lt;Datei&amp;gt;...&amp;quot; um die Änderungen im Arbeitsverzeichnis zu verwerfen)

  geändert:       index.html

  keine Änderungen zum Commit vorgemerkt (benutzen Sie &amp;quot;git add&amp;quot; und/oder &amp;quot;git commit -a&amp;quot;)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Git bemerkt automatisch, dass sich der Inhalt von &amp;ldquo;index.html&amp;rdquo; verändert hat.
Die Veränderung betrifft alle Änderungen seit dem letzten Commit.&lt;/p&gt;
&lt;p&gt;Die Ausgabe von &amp;ldquo;git diff&amp;rdquo; zeigt letztendlich die Änderungen an der Datei an:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git diff

diff --git a/index.html b/index.html
index 7a050c7..ea3b0af 100644
--- a/index.html
+++ b/index.html
@@ -5,13 +5,13 @@
&amp;lt;meta charset=&amp;quot;utf-8&amp;quot;&amp;gt;
&amp;lt;meta http-equiv=&amp;quot;X-UA-Compatible&amp;quot; content=&amp;quot;IE=edge&amp;quot;&amp;gt;
&amp;lt;meta name=&amp;quot;viewport&amp;quot; content=&amp;quot;width=device-width, initial-scale=1&amp;quot;&amp;gt;
-    &amp;lt;title&amp;gt;Bootstrap 101 Template&amp;lt;/title&amp;gt;
+    &amp;lt;title&amp;gt;Webseite mit Git&amp;lt;/title&amp;gt;

&amp;lt;!-- Bootstrap --&amp;gt;
&amp;lt;link href=&amp;quot;css/bootstrap.min.css&amp;quot; rel=&amp;quot;stylesheet&amp;quot;&amp;gt;
  &amp;lt;/head&amp;gt;
  &amp;lt;body&amp;gt;
-    &amp;lt;h1&amp;gt;Hello, world!&amp;lt;/h1&amp;gt;
+    &amp;lt;h1&amp;gt;Hallo Git!&amp;lt;/h1&amp;gt;

&amp;lt;!-- jQuery (necessary for Bootstrap&#39;s JavaScript plugins) --&amp;gt;
&amp;lt;script src=&amp;quot;https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js&amp;quot;&amp;gt;&amp;lt;/script&amp;gt;
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Git zeigt die Unterschiede zwischen der aktuellen Datei und der Datei an, die
zuletzt committet wurde. Entfernte Zeilen werden mit einem Minus zu Beginn der
Zeile angezeigt, neu hinzugefügte Zeilen wiederum mit einem Plus. Gleichen Effekt
hat es bei geänderten Zeilen.&lt;/p&gt;
&lt;p&gt;&lt;em&gt;Tipp:&lt;/em&gt; Zur Besseren Übersicht über die Ausgaben von Git im Terminal bietet es sich
an, die Farbausgabe zu aktivieren. Dies kann global in der Konfiguration mit
folgenden Befehl gesetzt werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git config --global color.ui true
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Gelöschte Zeilen werden hiermit rot dargestellt und neu hinzugefügte Zeilen grün.
Dieser Konfigurationsschalter wirkt sich allerdings nicht nur hier aus, sondern
auch an weiteren Stellen.&lt;/p&gt;
&lt;p&gt;Die Änderungen können wie gehabt wieder in den Staging Bereich gebracht werden
und anschließend committet werden:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;$ git add index.html
$ git commit -m &amp;quot;Titel und Überschrift angepasst.&amp;quot;
[master 24e65af] Titel und Überschrift angepasst.
1 file changed, 2 insertions(+), 2 deletions(-)
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Wenn man alle Befehle wie angegeben ausgeführt hat, besitzt das Repository
drei Commits.&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;In diesem Teil wurden die grundlegendsten Git Kommandos erläutert. Man weiß nun
unter anderem, wie man Dateien zu einem Repository hinzufügt, ein Commit tätigt
und wie man sich das Repository-Log anschauen kann.&lt;/p&gt;
&lt;p&gt;Der nächste Teil behandelt das Branching Modell von Git.&lt;/p&gt;
&lt;ul&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2014/11/01/git-fur-einsteiger-teil-2/&#34;&gt;Hier geht es zu Teil 2&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;li&gt;&lt;a href=&#34;https://svij.org/blog/2015/01/12/git-fur-einsteiger-teil-3/&#34;&gt;Hier geht es zu Teil 3&lt;/a&gt;&lt;/li&gt;&lt;/li&gt;
&lt;/ul&gt;
</description>
    </item>
    
    <item>
      <title>Ein Rückblick auf die Ubucon 2014</title>
      <link>https://svij.org/blog/2014/10/21/ein-r%C3%BCckblick-auf-die-ubucon-2014/</link>
      <pubDate>Tue, 21 Oct 2014 20:20:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/10/21/ein-r%C3%BCckblick-auf-die-ubucon-2014/</guid>
      <description>&lt;p&gt;Letztes Wochenende fand die Ubucon in Katlenburg-Lindau statt. Bereits am Sonntag
&lt;a href=&#34;https://svij.org/blog/2014/10/19/fertig-git-workshop-auf-der-ubucon-2014/&#34;&gt;veröffentlichte&lt;/a&gt;
ich meine Folien vom Git-Workshop.&lt;/p&gt;
&lt;h3 id=&#34;vorbereitung&#34;&gt;Vorbereitung&lt;/h3&gt;
&lt;p&gt;Nachdem ich im letzten Jahr in das Organisationsteam der Ubucon hereingerutscht
bin, beteiligte ich mich auch dieses Jahr bei der Organisation. Im Gegensatz zu letztem
Jahr war die Organisation generell eher etwas ruhiger. Manchmal auch zu ruhig,
wie mir schien. Durch den eher ungewöhnlichen kleinen Ort wurden weniger Vorträge
und Workshops eingereicht. Zudem haben sich vergleichsweise wenige Leute angemeldet.
Ich selbst hatte ein wenig Zweifel, ob die Ubucon gut wird. Zum Glück haben
sich meine Befürchtungen nicht bewahrheitet, aber dazu später mehr.&lt;/p&gt;
&lt;h3 id=&#34;die-veranstaltung&#34;&gt;Die Veranstaltung&lt;/h3&gt;
&lt;h4 id=&#34;freitag&#34;&gt;Freitag&lt;/h4&gt;
&lt;p&gt;Die Veranstaltung fing wie gewohnt auch dieses Mal an einem Freitag an. Bei der
Anmeldung bekam jeder Besucher ein schönes Namensschild mit vollen Namen
sowie Nicknamen drauf. Nachdem letztes Jahr mein Name
&lt;a href=&#34;https://plus.google.com/u/0/+SujeevanVijayakumaran/posts/iTDHcSdbxu4&#34;&gt;scheinbar zu lang&lt;/a&gt;
war, verschwand diesmal ein Buchstabe im Nachnamen. Also quasi alles wie immer. :-)&lt;/p&gt;
&lt;img src=&#34;https://svij.org/graphics/ubucon2014_namensschild.webp&#34; width=&#34;250&#34; style=&#34;float:right; margin:20px;&#34;&gt;
&lt;p&gt;Torsten Franz hielt als Hauptorganisator zunächst seine kurze Eröffnungsrede und
erzählte anschließend in seinem Vortrag „10 Jahre Ubuntu, 10 Jahre Community“
über die Entwicklung von Ubuntu und der Community. Anschließend begab sich ein
Teil zum „Ritteressen“ welches in der benachbarten Burg stattfand. Ich selbst
war dort allerdings nicht mit dabei.&lt;/p&gt;
&lt;h4 id=&#34;samstag&#34;&gt;Samstag&lt;/h4&gt;
&lt;p&gt;Am Samstag um 10 Uhr fing mein Git-Workshop an. Zu Beginn gab es, die für Konferenzen
bekannten, WLAN-Probleme, die sich auch in meinem Git-Workshop ausgewirkt haben.
Es dauerte daher eine Weile bis alle Teilnehmer an ihren Laptops
erfolgreich Git installieren konnten. Auf Grund der Probleme musste ich auch
kurzfristig meinen Workshop leicht umplanen, damit für den Rest des Workshops kein Internet
gebraucht wurde. Abgesehen von den Problemen, lief es gut, wie ich es ja bereits
im anderen Blog-Artikel schrieb.&lt;/p&gt;
&lt;p&gt;Am restlichen Tag besuchte ich keine Vorträge mehr, sondern unterhielt mich lieber
mit den vielen anderen netten Leuten. Am Abend fanden dann die beiden Social-Events
statt. Während ein großer Teil zum &lt;a href=&#34;http://theater-der-nacht.de&#34;&gt;„Theater der Nacht“&lt;/a&gt;
gefahren ist, waren die übrigen weiterhin in der Schule, wo Live-Musik gespielt
wurde. Die Live-Musik war ganz okay, aber so wie die übrigen vom Theater geschwärmt
haben, bereue ich es im Nachhinein doch dort nicht hingegangen zu sein.
Bernhard hat dort einige &lt;a href=&#34;https://www.flickr.com/photos/bhanakam/sets/72157648465004507/&#34;&gt;sehr schöne Bilder&lt;/a&gt;
geschossen.&lt;/p&gt;
&lt;h4 id=&#34;sonntag&#34;&gt;Sonntag&lt;/h4&gt;
&lt;p&gt;Am Sonntag besuchte ich lediglich zwei Vorträge. Dies war zum einen der Talk
über LVM sowie über systemd. Beide Vorträge wurden von &lt;a href=&#34;http://blog.stefan-betz.net/&#34;&gt;Stefan J. Betz&lt;/a&gt;
gehalten. Sie waren nicht nur informativ, sondern auch ganz lustig. ;-)
Am frühen Nachmittag endete auch schon die Ubucon. Durch die vielen Helfer vor Ort
war das Gröbste auch schon zügig abgebaut und aufgeräumt. Da einige Besucher
vom Bahn-Streik betroffen waren, bildeten sich idealerweise noch spontan Mitfahrgelegenheiten.&lt;/p&gt;
&lt;h4 id=&#34;vor-ort&#34;&gt;Vor-Ort&lt;/h4&gt;
&lt;p&gt;Der Ort war klasse! Obwohl es eine Grundschule war, war die technische Ausstattung
ziemlich gut. Die Schule besitzt einige Smartboards mit Beamer, die während
der Veranstaltung zum Einsatz kamen. Direkt im Eingangsbereich befand sich
ein großer Aufenthaltsraum in dem man seine freie Zeit verbringen konnte. Dort
befanden sich auch einige Rechner mit verschiedenen Linux-Distributionen und
Desktop-Umgebungen, welche die Besucher ausprobieren konnten. Die Idee kam von
dem Organisator vor Ort und auch ich fand das ganz nett.&lt;/p&gt;
&lt;p&gt;Auch neu war diesmal eine Spiele-Ecke. Es gab zwei Räume, in dem jeweils zwei
Rechner mit Spielen vorinstalliert waren. Zudem gab es insgesamt auch noch zwei
Kicker-Tische, die nicht nur ich genutzt habe. Sowohl die Idee als auch die
Umsetzung waren ganz nett gemacht, da man sich dort auch ganz nett unterhalten
konnte. Für die nächsten Ubucons hoffe ich, dass es so etwas nochmals gibt.&lt;/p&gt;
&lt;p&gt;Jeder Vortragende hat übrigens einen Beutel voll mit Inhalt aus der Region bekommen.
In dem Beutel befanden sich diverse Wurst-Sorten, Bier, Wein und noch eine Sauce.
Auch wenn ich mit den meisten Sachen nicht viel anfangen kann, finde
ich dies ebenfalls eine tolle Idee und auch eine nette Geste für die Vortragenden.&lt;/p&gt;
&lt;p&gt;Die Verpflegung, welche bei der Ubucon immer im Teilnahmepreis enthalten ist,
war ebenfalls deutlich besser als sonst. Die letzten Jahre wurden lediglich
belegte Brötchen bei einer Bäckerei bestellt, die dann verzehrt werden konnten.
Dieses Mal wurden die Brötchen von fleißigen Helfern geschmiert. Diese sorgten
auch dafür, dass es durchgehend warme Bockwürstchen, Hühner- und Kürbis-Suppe gab.
Diese schmeckten jeweils nach meiner Einschätzung gut und brachten eine gute
Abwechslung rein. Dieses Jahr wurde daher ausnahmweise nicht mehr „Esst mehr Brötchen!“,
sondern „Esst mehr Würstchen!“ gerufen ;-).&lt;/p&gt;
&lt;h3 id=&#34;fazit&#34;&gt;Fazit&lt;/h3&gt;
&lt;p&gt;Die Ubucon war toll! Im Vergleich zu den letzten Jahren ist sie zwar, was die
Teilnehmer- und Vortragsanzahl angeht, kleiner geworden, allerdings war es diesmal
vor Ort sehr sehr gut organisiert. Der Hauptorganisator Olaf Bialas hat
da sehr gute Arbeit geleistet. Darunter fallen besonders auch seine eigenen Ideen
die er eingebracht hat, etwa die Spiele-Ecke und der Rechner-Kreis mit den verschiedenen
Distrubutionen und dessen Desktop-Umgebungen.&lt;/p&gt;
&lt;p&gt;Für die Zukunft hoffe ich mir, dass die Ubucon ähnlich gut laufen wie dieses Mal.
Ein Veranstaltungsort für nächstes Mal steht allerdings noch nicht fest. Prinzipiell
finde ich es immer gut, wenn es jedes Jahr einen anderen, neuen Ort gibt. So sieht
man nicht nur andere Städte, sondern man lernt auch viele neue nette Leute kennen.
Insbesondere der letzte Punkt ist der hauptsächliche Grund, warum ich nicht nur
die Ubucon besuche, sondern auch bei der Organisation mithelfe.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Fertig! Git-Workshop auf der Ubucon 2014</title>
      <link>https://svij.org/blog/2014/10/19/fertig-git-workshop-auf-der-ubucon-2014/</link>
      <pubDate>Sun, 19 Oct 2014 22:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/10/19/fertig-git-workshop-auf-der-ubucon-2014/</guid>
      <description>&lt;p&gt;An diesem Wochenende fand die Ubucon 2014 in der Gemeinde &lt;a href=&#34;https://de.wikipedia.org/wiki/Katlenburg-Lindau&#34;&gt;Katlenburg-Lindau&lt;/a&gt;
statt. Einen Rückblick auf die diesjährige Ubucon folgt an dieser Stelle
allerdings noch nicht. Dies folgt im Laufe der Woche.&lt;/p&gt;
&lt;p&gt;Im August &lt;a href=&#34;https://svij.org/blog/2014/08/11/git-workshop-auf-der-ubucon-2014/&#34;&gt;hatte ich bereits angekündigt&lt;/a&gt;,
dass ich dieses Jahr einen Git-Workshop auf der Ubucon halten werde. Wie geplant,
tat ich dies dann auch. Für mich war der Workshop generell mal was neues, da ich bislang
lediglich Vorträge auf der Ubucon gehalten habe. Aus demselben Grund war auch
die Zeitplanung schwierig. Meine Schätzung von zwei bis drei Stunden hat ungefähr
hingehauen, sodass wir nach knapp 2,5h fertig waren.&lt;/p&gt;
&lt;p&gt;Insgesamt haben knapp 17 Leute teilgenommen. Die Anzahl war zum Glück nicht zu
groß, sodass man einen guten Überblick halten konnte. In dem Workshop behandelte
ich die grundsätzlichen Git-Features. Dies umfasst das einfache Committen
von Änderungen, das Arbeiten mit Branches, sowie die Nutzung von Remote-Repositories.&lt;/p&gt;
&lt;p&gt;Die Folien habe ich dieses Mal erstmals auf Speakerdeck.com hochgeladen. Diese
lassen sich &lt;a href=&#34;https://speakerdeck.com/svij/git-workshop-fur-einsteiger&#34;&gt;hier&lt;/a&gt;
ansehen. Man sollte jedoch beachten, dass hier wie üblich meine gesprochenen
Worte fehlen und sich die Folien daher grundsätzlich größtenteils an die
Teilnehmer des Workshops richtet. Der Quell-Dateien finden sich separat
in einem &lt;a href=&#34;http://github.com/svijee/git-workshop&#34;&gt;Repository auf Github&lt;/a&gt;.&lt;/p&gt;
&lt;p&gt;Bald sollte dann auch endlich der erste Teil des Git-Tutorials fertig sein. Den
veröffentliche ich dann, wie gewohnt, hier und in eine der kommenden Ausgaben
von &lt;a href=&#34;http://www.freiesmagazin.de/&#34;&gt;freiesMagazin.de&lt;/a&gt;.&lt;/p&gt;
&lt;script async class=&#34;speakerdeck-embed&#34; data-id=&#34;29bba9a039f2013278c35eb6dd3f65c6&#34; data-ratio=&#34;1.33333333333333&#34; src=&#34;//speakerdeck.com/assets/embed.js&#34;&gt;&lt;/script&gt;
</description>
    </item>
    
    <item>
      <title>Rezension: Spieleprogrammierung mit Android Studio</title>
      <link>https://svij.org/blog/2014/10/05/rezension-spieleprogrammierung-mit-android-studio/</link>
      <pubDate>Sun, 05 Oct 2014 10:30:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2014/10/05/rezension-spieleprogrammierung-mit-android-studio/</guid>
      <description>&lt;p&gt;Das Buch „Spieleprogrammierung mit Android Studio“ vom Autor Uwe Post erschien
2014 in der ersten Auflage. Auf fast 400 Seiten erlernt man sowohl den Umgang
mit Android Studio als auch die Spieleprogrammierung unter Android.&lt;/p&gt;
&lt;h3 id=&#34;was-steht-drin&#34;&gt;Was steht drin?&lt;/h3&gt;
&lt;p&gt;Das Buch ist in elf Kapiteln unterteilt und umfasst 381 Seiten. Der Autor
Uwe Post ist Chefentwickler einer Smartphone-Spielerfirma. Veröffentlicht
wurde es vom Galileo Computing Verlag.&lt;/p&gt;
&lt;p&gt;Das erste Kapitel ist die „Einführung“ in der ein kurzer Überblick über
Spiele-Klassiker gegeben wird. Im darauffolgenden zweiten Kapitel erfolgt
die erste Einführung in Android Studio, in dem nicht nur die Installation
kurz erläutert wird, sondern auch einige Tipps zur Arbeitserleichterung gegeben
werden. Danach folgt auch schon das erste kleine Spiel, welches im dritten
Kapitel erstellt und erklärt wird. Das aufgeführte Spiel wird dabei
Schritt für Schritt aufgebaut. Der Fokus liegt in diesem Kapitel auf die
Grundlagen eines Android-Projekts unter Android Studio.&lt;/p&gt;
&lt;p&gt;Im vierten Kapitel folgt erstmals der Einsatz von Bildbearbeitungsprogrammen.
In diesem Buch wird dabei grundsätzlich Gimp genutzt. Weiterhin werden Animationen
behandelt, so dass man sinnvolle Animationen in Spielen einbauen kann.
Smartphones besitzen grundsätzlich sehr viele Sensoren, die man sehr gut
für Spiele nutzen kann. Das fünfte Kapitel behandelt daher die Nutzung vom
Lagesensor. Im sechsten Kapitel folgt dann die Nutzung von Audio und Musik-Stücken.&lt;/p&gt;
&lt;p&gt;Eine neue relativ neue Art von Spielen sind location-based Spiele. Im siebten Kapitel
wird ein kleines Spiel programmiert, in dem man sich frei herumbewegen muss.
Die Geolokation erfolgt mittels GPS.
Die letzten Kapitel im Buch vertiefen die Art und Weise der Spiele
sowie auch die Komplexität. Im achten Kapitel wird die Bibliothek libgdx verwendet um ein
schnelles 2D-Spiel zu erzeugen, während es im neuten Kapitel an die Königsdisziplin
geht: 3D-Spiele. Auch für 3D-Spiele wird die Open Source Bibliothek libgdx verwendet.
Die Beschreibungen und Erläuterungen gehen relativ weit, so dass man nicht nur
ein Szenenbild aufbaut, sondern auch ein kleines 3D-Labyrinth erstellt.&lt;/p&gt;
&lt;p&gt;Die letzten beiden Kapitel beziehen sich nicht mehr direkt auf die
Spiele-Programmierung. Das zehnte Kapitel beschäftigt sich mit Social-Gaming,
also wie man den Spielstand seines Spiels in Google Play Games Services
einbindet oder auch wie man einen Facebook-Login realisiert. Das letzte
Kapitel behandelt eher den wirtschaftlichen Aspekt von Spielen, nämlich
die Monetarisierung. Der Autor gibt einige Tipps, welche Arten von Monetariserung
es gibt, und wie man sie sinnvoll einsetzen kann, um im Idealfall gutes Geld
zu verdienen.&lt;/p&gt;
&lt;h3 id=&#34;wie-liest-es-sich&#34;&gt;Wie liest es sich?&lt;/h3&gt;
&lt;p&gt;Das Buch liest sich durchwegs sehr gut. Der Autor entwickelt in jedem Kapitel
ein eigenes Spiel, welches zum Thema passt. Die Erläuterungen sind meistens
nicht zu kurz, aber auch nicht sonderlich lang. Nach dem ein oder anderen
Code-Schnipsel folgt meist eine prägnante Erklärung was genau getan wird.&lt;/p&gt;
&lt;p&gt;Für dieses Buch sind nicht nur gute Java-Kenntnisse Pflicht, sondern auch
grundsätzliches Verständnis der Programmierung von Android-Apps sind hier
sehr sinnvoll. Installationsanleitungen sind kurz gehalten, die erste Installation
von Android Studio wird nicht im Detail erklärt, da dies die Leser des Buches
sowieso können sollten. Praktisch ist vorallem, dass alle Anwendungen im Buch Open Source
Anwendungen sind. Neben Gimp, wird auch Inkscape kurz thematisiert.
Der Autor selbst nutzt nach eigenen Angaben Ubuntu, das Buch ist allerdings
nicht zwangsläufig auf Ubuntu ausgerichtet, sondern behandelt alle drei
Betriebssysteme zu gleichen Anteilen.&lt;/p&gt;
&lt;h3 id=&#34;kritik&#34;&gt;Kritik&lt;/h3&gt;
&lt;p&gt;Das Buch bietet einen guten Einstieg in die Programmierung von Spielen für Android.
Die Erklärungen sind durchgängig gut zu verstehen und vieles lässt sich einfach
nachvollziehen. Man merkt, dass der Autor sehr gute Erfahrungen in der
Spiele-Programmierung besitzt. Es kommen durchaus viele Hinweise, wenn einige
Tools oder Verfahren umständlich oder kompliziert sind. Die Schreibweise
von Uwe Post ist zudem sehr angenehm zu lesen.&lt;/p&gt;
&lt;p&gt;Für knapp 35€ bekommt man daher ein gutes Buch über die Android-Spieleprogrammierung.
Der Leser gewinnt dabei ein sehr guten Einstieg in die Welt der Spiele, worauf
man dann schon fast sein ersten Spiel programmieren und veröffentlichen kann.
Das Buch lässt sich insbesondere für die jenigen empfehlen, welche gute
Erfahrung in der Android-Entwicklung besitzen und in die Spiele-Programmierung
einsteigen wollen.&lt;/p&gt;
&lt;h4 id=&#34;buchinfo&#34;&gt;Buchinfo:&lt;/h4&gt;
&lt;p&gt;&lt;strong&gt;Titel:&lt;/strong&gt; &lt;a href=&#34;https://www.galileo-press.de/spieleprogrammierung-mit-android-studio_3537/&#34;&gt;Spieleprogrammierung mit Android Studio&lt;/a&gt;&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Autor:&lt;/strong&gt; Uwe Post&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Verlag:&lt;/strong&gt; Galileo Computing, 2014&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Umfang:&lt;/strong&gt; 381 Seiten&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;ISBN:&lt;/strong&gt; 978-3-8362-2760-5&lt;/p&gt;
&lt;p&gt;&lt;strong&gt;Preis:&lt;/strong&gt; 34,90 (gebunden), 29,90 (E-Book)&lt;/p&gt;
&lt;p&gt;Da es schade wäre, wenn das Buch bei mir lediglich im Regal
verstaubt, wird es verlost. Dies ist „drüben“ bei &lt;a href=&#34;http://www.freiesmagazin.de/20141005-oktoberausgabe-erschienen&#34;&gt;freiesMagazin&lt;/a&gt;
in den Kommentaren möglich.&lt;/p&gt;
</description>
    </item>
    
    <item>
      <title>Bilder verkleinern mit Imagemagick</title>
      <link>https://svij.org/blog/2011/06/08/bilder-verkleinern-mit-imagemagick/</link>
      <pubDate>Wed, 08 Jun 2011 23:00:00 +0200</pubDate>
      <author>mail@svij.org (Sujeevan Vijayakumaran)</author>
      <guid>https://svij.org/blog/2011/06/08/bilder-verkleinern-mit-imagemagick/</guid>
      <description>&lt;p&gt;Eine Methode um schnell und relativ einfach Bilder mittels eines Scripts zu verkleinern, ist die Möglichtkeit ImageMagick zu nutzen. Dabei muss man zunächst ImageMagick aus den Paketquellen installieren.&lt;/p&gt;
&lt;p&gt;Um nun die Bilder zu verkleinern, nutze ich das folgende Script, welches in dem Ordner mit den Bildern liegt.&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;mkdir small;
for i in *.JPG;
do
j=${i//\.JPG/};
convert -resize 50% -quality 65 $i small/${j}_klein.JPG;
done
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Nach dem Erstellen des Scriptes muss man die Datei ausführbar machen. Dies geschieht am einfachsten im Terminal mittels:&lt;/p&gt;
&lt;pre&gt;&lt;code&gt;chmod +x dateiname
&lt;/code&gt;&lt;/pre&gt;
&lt;p&gt;Nützlich zu wissen ist auch, wie das Script genau arbeitet. Zunächst wird in dem Ordner ein Ordner mit dem Namen small erstellt. In der darauffolgenden Schleife wird der convert Befehl von ImageMagick ausgeführt. In diesem Fall werden dabei zwei Parameter übergeben. Das ist zum einen -resize 50% und des Weiteren -quality 65. Bei dem Parameter resize kann man sowohl einen Prozentsatz als auch eine Auflösung zum Verkleinern bzw auch zum Vergrößern des Bildes angeben. Mit quality lässt sich die Qualität des Bildes beeinflussen. Je geringer die Auflösung und die Qualität ist, desto kleiner wird die Dateigröße, als auch die Qualität des Bildes. Für den Webgebrauch sind Bilder mit einer kleinen Dateigröße wichtig, da damit neben des verschnellerten Uploads auch die Anzeige beim Webseiten-Besucher beschleunigt wird. Meiner Meinung nach erkennt man bei der halbierung der Auflösung und Reduzierung der Qualität nur geringfügige Qualitätsverluste, die man für den Webgebrauch in Galerien einstecken kann. Aus diesem
Grunde verkleinere ich alle meine Bilder die ich in meine Galerie hochlade mit diesen Einstellungen.&lt;/p&gt;
</description>
    </item>
    
  </channel>
</rss>
