Talk zum Thema Nebenläufigkeit auf der OOP 2016 in München. Neben einer prinzipiellen Einführung und Motivation werden die Sprachen Erlang/OTP, Google Go und Pony vorgestellt. Weiter sind einige typische Designmuster sowie Fallstricke enthalten. Der Vortrag hatte die Dauer von 90 Minuten.
Talk zum Thema Nebenläufigkeit auf der OOP 2016 in München. Neben einer prinzipiellen Einführung und Motivation werden die Sprachen Erlang/OTP, Google Go und Pony vorgestellt. Weiter sind einige typische Designmuster sowie Fallstricke enthalten. Der Vortrag hatte die Dauer von 90 Minuten.
Provisionierung von Dockerhosts und -Containern mit Terraform, Ansible und LXD auf Blech und Cloud
Lästige und aufwändige manuelle Serverinstallation kann auf einfache Art durch automatisierte Provisionierung und Konfiguration der Infrastruktur ersetzt werden. Dieser Vortrag zeigt einen Ansatz, bei dem die Definition der Infrastruktur in voll maschinenlesbarer und ausführbarer Form in einem git repo anstatt in den Köpfen der (oder des) Engineers vorhanden sind.
Es wird gezeigt, wie das Verfahren sowohl auf Blech (d.h. auf lokalen physischen Maschinen) als auch in der Cloud angewendet werden kann, und somit eine grosse Übereinstimmung zwischen Test-/Integrations- und Produktionsinfrastruktur erreicht wird.
Die vorgestellten Werkzeuge sind terraform und ansible für Provisionierung und Konfigurationsmanagement, sowie lxd (nur lokal) und docker für System- und Applikationscontainer. Die vollständige Codebasis ist auf github verfügbar, so dass alle TeilnehmerInnen auch sofort mit eigenen Experimenten loslegen können.
".NET und jetzt!" C# in 21 Tagen oder doch besser Best PracticesGFU Cyrus AG
Konzepte, Werkzeuge und Ideen aus der Praxis für bessere und erfolgreichere .NET-Softwareprojekte.
* Klassen/Objekte/Komponenten
* Mehrschichtige .NET-Anwendungen
* Bibliotheken und Pattern
* Frameworks und Tools
* Unit Testing und Codeanalyse
* Continous Integration und Versionsverwaltung
* Dokumentation und Instrumentation
Einführung in die funktionale Programmierung mit ClojureSascha Koch
Diese Präsentation ist im Rahmen eines Treffens der Java User Group Bielefeld entstanden.
Ich habe eine Einführung in die funktionale Programmierung an Hand des Lambda Kalküls gegeben. Anschließend haben wir uns die Programmiersprache Clojure angeschaut und einige Beispiele durchgesprochen.
Anschließend hat Daniel Rosowski noch funktionale Programmierung mit Guava und Java 8 vorgestellt: http://de.slideshare.net/DanielRosowski/real-lifefp
OSMC 2008 | Programmierung von Nagios-Plugins für NetApp Speichergeräte by In...NETWAYS
Dieser Workshop ist in erster Linie für Konferenzteilnehmer gedacht, die sich für Plugin-Programmierung interessieren.
Der Workshop zeigt auf, welche überwachenswerten Daten und Parameter es auf einem NetApp-Filer gibt und wie die Zugänge zu diesen Daten (Telnet, HTTP, SNMP, SSH, XML/Webservices, Data ONTAP APIs) sind. Ingo Lantschner wird eine theoretische Einführung und Demonstration an Hand des NetApp-Simulators präsentieren und mit den Teilnehmern ein Demo-Plugin auf Basis der o.g. Erkenntnisse entwickeln, anschließend erfolgt der Upload des Plugins auf Nagios-Exchange.
Verteilte Anwendungen bei Azure mit Docker und KubernetesGregor Biswanger
Kubernetes ermöglicht eine Automatisierung der Bereitstellung, Skalierung und Verwaltung von verteilten Docker-Container. Der Einstieg, die Umsetzung und Wartung hingegen ist eine extreme Herausforderung und kostet am Ende nicht nur viel Geld, sondern auch Ihre Nerven. Microsoft Azure bietet mit den Azure Kubernetes Services (Kurz AKS) die Erlösung, der soeben genannten Schmerzen. In dieser Session zeigt Ihnen der Docker- und Azure-Experte Gregor Biswanger einen Überblick von Kubernetes und wie einfach Azure für uns eine Kuberenetes-Landschaft herbeizaubern kann.
Code Days 2019, München: Vortrag von Johannes Weigend (@JohannesWeigend, Technischer Geschäftsführer bei QAware)
=== Dokument bitte herunterladen, falls unscharf! Please download slides if blurred! ===
Abstract:
Programmiersprachen für die Cloud - Java und Go im Vergleich
Java ist nach dem Tiobe Index 2018 unangefochten Platz 1 bei den weltweit eingesetzten Programmiersprachen. Java ist ausgereift, stabil und verfügt über ein immenses Open Source Ökosystem. Was will man mehr? Obwohl Java gerade für die Backend Entwicklung attraktiv ist, hat Google 2008 eine eigene Programmiersprache Open Source gestellt: Golang oder kurz Go. Der Vortrag beleuchtet die Stärken und Schwächen von Go gegenüber Java, gibt Hinweise für welche Projekte Go eine gute Alternative ist, und wie ein Best of Breed Ansatz aussehen kann. Interessant an Go ist, dass die Grundbausteine von Cloud Plattformen wie OpenShift oder die Google Container Plattform mit Go erstellt wurden. Docker, Kubernetes, Helm, Grafana oder Prometheus ‒ alles ist mit Go programmiert. Die Fragen aus der Sicht von Java-Experten sind: Was macht Go für die Cloud so interessant? Gibt es Funktionen, die Java Programmierer kennen sollten, und wenn ja, welche?
Ob ASP.net MVC, NuGet oder die codebasierten Migrationen bei EF – immer mehr Konzepte und Ideen schwappen von Ruby in die .Net Welt. Wieso aber gerade von Ruby? Und was macht Rails so beliebt bei Webentwicklern?
Ruby ist wie C# eine objektorientierte Programmiersprache. Damit enden die Gemeinsamkeiten aber schon fast. Die vielen fremden Konzepte und Ansätze machen einen Einstieg in Ruby und Rails nicht gerade einfach. Aber genau in diesen Unterschieden liegen die Stärken und machen Ruby so interessant.
Dieser Vortrag gibt einen Überblick über Ruby und Rails und hilft einem sich in dieser ungewohnten Umgebung zu Recht zu finden.
Provisionierung von Dockerhosts und -Containern mit Terraform, Ansible und LXD auf Blech und Cloud
Lästige und aufwändige manuelle Serverinstallation kann auf einfache Art durch automatisierte Provisionierung und Konfiguration der Infrastruktur ersetzt werden. Dieser Vortrag zeigt einen Ansatz, bei dem die Definition der Infrastruktur in voll maschinenlesbarer und ausführbarer Form in einem git repo anstatt in den Köpfen der (oder des) Engineers vorhanden sind.
Es wird gezeigt, wie das Verfahren sowohl auf Blech (d.h. auf lokalen physischen Maschinen) als auch in der Cloud angewendet werden kann, und somit eine grosse Übereinstimmung zwischen Test-/Integrations- und Produktionsinfrastruktur erreicht wird.
Die vorgestellten Werkzeuge sind terraform und ansible für Provisionierung und Konfigurationsmanagement, sowie lxd (nur lokal) und docker für System- und Applikationscontainer. Die vollständige Codebasis ist auf github verfügbar, so dass alle TeilnehmerInnen auch sofort mit eigenen Experimenten loslegen können.
".NET und jetzt!" C# in 21 Tagen oder doch besser Best PracticesGFU Cyrus AG
Konzepte, Werkzeuge und Ideen aus der Praxis für bessere und erfolgreichere .NET-Softwareprojekte.
* Klassen/Objekte/Komponenten
* Mehrschichtige .NET-Anwendungen
* Bibliotheken und Pattern
* Frameworks und Tools
* Unit Testing und Codeanalyse
* Continous Integration und Versionsverwaltung
* Dokumentation und Instrumentation
Einführung in die funktionale Programmierung mit ClojureSascha Koch
Diese Präsentation ist im Rahmen eines Treffens der Java User Group Bielefeld entstanden.
Ich habe eine Einführung in die funktionale Programmierung an Hand des Lambda Kalküls gegeben. Anschließend haben wir uns die Programmiersprache Clojure angeschaut und einige Beispiele durchgesprochen.
Anschließend hat Daniel Rosowski noch funktionale Programmierung mit Guava und Java 8 vorgestellt: http://de.slideshare.net/DanielRosowski/real-lifefp
OSMC 2008 | Programmierung von Nagios-Plugins für NetApp Speichergeräte by In...NETWAYS
Dieser Workshop ist in erster Linie für Konferenzteilnehmer gedacht, die sich für Plugin-Programmierung interessieren.
Der Workshop zeigt auf, welche überwachenswerten Daten und Parameter es auf einem NetApp-Filer gibt und wie die Zugänge zu diesen Daten (Telnet, HTTP, SNMP, SSH, XML/Webservices, Data ONTAP APIs) sind. Ingo Lantschner wird eine theoretische Einführung und Demonstration an Hand des NetApp-Simulators präsentieren und mit den Teilnehmern ein Demo-Plugin auf Basis der o.g. Erkenntnisse entwickeln, anschließend erfolgt der Upload des Plugins auf Nagios-Exchange.
Verteilte Anwendungen bei Azure mit Docker und KubernetesGregor Biswanger
Kubernetes ermöglicht eine Automatisierung der Bereitstellung, Skalierung und Verwaltung von verteilten Docker-Container. Der Einstieg, die Umsetzung und Wartung hingegen ist eine extreme Herausforderung und kostet am Ende nicht nur viel Geld, sondern auch Ihre Nerven. Microsoft Azure bietet mit den Azure Kubernetes Services (Kurz AKS) die Erlösung, der soeben genannten Schmerzen. In dieser Session zeigt Ihnen der Docker- und Azure-Experte Gregor Biswanger einen Überblick von Kubernetes und wie einfach Azure für uns eine Kuberenetes-Landschaft herbeizaubern kann.
Code Days 2019, München: Vortrag von Johannes Weigend (@JohannesWeigend, Technischer Geschäftsführer bei QAware)
=== Dokument bitte herunterladen, falls unscharf! Please download slides if blurred! ===
Abstract:
Programmiersprachen für die Cloud - Java und Go im Vergleich
Java ist nach dem Tiobe Index 2018 unangefochten Platz 1 bei den weltweit eingesetzten Programmiersprachen. Java ist ausgereift, stabil und verfügt über ein immenses Open Source Ökosystem. Was will man mehr? Obwohl Java gerade für die Backend Entwicklung attraktiv ist, hat Google 2008 eine eigene Programmiersprache Open Source gestellt: Golang oder kurz Go. Der Vortrag beleuchtet die Stärken und Schwächen von Go gegenüber Java, gibt Hinweise für welche Projekte Go eine gute Alternative ist, und wie ein Best of Breed Ansatz aussehen kann. Interessant an Go ist, dass die Grundbausteine von Cloud Plattformen wie OpenShift oder die Google Container Plattform mit Go erstellt wurden. Docker, Kubernetes, Helm, Grafana oder Prometheus ‒ alles ist mit Go programmiert. Die Fragen aus der Sicht von Java-Experten sind: Was macht Go für die Cloud so interessant? Gibt es Funktionen, die Java Programmierer kennen sollten, und wenn ja, welche?
Ob ASP.net MVC, NuGet oder die codebasierten Migrationen bei EF – immer mehr Konzepte und Ideen schwappen von Ruby in die .Net Welt. Wieso aber gerade von Ruby? Und was macht Rails so beliebt bei Webentwicklern?
Ruby ist wie C# eine objektorientierte Programmiersprache. Damit enden die Gemeinsamkeiten aber schon fast. Die vielen fremden Konzepte und Ansätze machen einen Einstieg in Ruby und Rails nicht gerade einfach. Aber genau in diesen Unterschieden liegen die Stärken und machen Ruby so interessant.
Dieser Vortrag gibt einen Überblick über Ruby und Rails und hilft einem sich in dieser ungewohnten Umgebung zu Recht zu finden.
Einführung in Vagrant und wie es als lokale Entwicklungsumgebung verwendet werden kann.
Präsentation von März 2015.
Themen: Vagrant CLI, vagrant share, Provider, Boxes, Provisioning, Netzwerk, Synced Folders, Multi-Maschine Setup, Vergleich mit Docker
Vortrag der OOP 2014
Überblick über die Vorteile der Programmiersprache Go für skalierbare Anwendungen sowie ein Einblick in hierbei zu beachtende Probleme und ihre Lösung.
Kubernetes und Docker sind trotz des hohen Verbreitungsgrads noch relativ junge Technologien. Viele Menschen machen gerade gute und teilweise auch schmerzliche Erfahrungen mit beiden. Der Vortrag bietet einen Katalog an Patterns und Antipatterns bei der Entwicklung von Anwendungen auf Basis Kubernetes und Docker. Der Katalog repräsentiert dabei die Erfahrung aus mehreren Industrieprojekten, die es bis in Produktion geschafft haben.
Es geht darum, was man bei Docker-Files und Kubernetes-Deskriptoren richtig und falsch machen kann; welche Architekturbausteine man einsetzen sollte; wie die Continuous Delivery Pipeline gestaltet werden sollte und wie Anwendungen auf Cloud-Native-Plattformen gut betreibbar und diagnostizierbar gemacht werden können.
Docker und Kubernetes Patterns & Anti-PatternsQAware GmbH
JavaLand 2018, Brühl: Vortrag von Josef Adersberger (@adersberger, CTO bei QAware).
Abstract:
Kubernetes und Docker sind trotz des hohen Verbreitungsgrads noch relativ junge Technologien. Viele Menschen machen gerade gute und teilweise auch schmerzliche Erfahrungen mit beiden. Der Vortrag bietet einen Katalog an Patterns und Antipatterns bei der Entwicklung von Anwendungen auf Basis Kubernetes und Docker. Der Katalog repräsentiert dabei die Erfahrung aus mehreren Industrieprojekten, die es bis in Produktion geschafft haben.
Es geht darum, was man bei Docker-Files und Kubernetes-Deskriptoren richtig und falsch machen kann; welche Architekturbausteine man einsetzen sollte; wie die Continuous Delivery Pipeline gestaltet werden sollte und wie Anwendungen auf Cloud-Native-Plattformen gut betreibbar und diagnostizierbar gemacht werden können.
Folien aus einem Unixkurs, den ich gehalten habe.
Im Kurs ging es um
Allgemeines zu Unix
Text editieren mit VIM Standard-Unix-Befehle Dateisysteme
Useraccounts und Rechte Prozess- und Speicherverwaltung Shellscripting
Rufen Sie nicht an – wir rufen Sie an! | Server-sent Events und Web-Sockets i...OPEN KNOWLEDGE GmbH
Speaker: Sebastian Reiners
Seit Java EE 7 stehen auch Enterprise-Entwicklern Server-Sent Events und WebSockets in standardisierter Form zur Verfügung. Höchste Zeit also, sich diese andere Art der Kommunikation im Web einmal näher anzusehen. Was sind Server-Sent Events und WebSockets überhaupt, was sind ihre Vorteile und wo bieten sich sinnvolle Anwendungsbereiche?
Im Rahmen der Vorstellung der unterschiedlichen Ansätze werden praktische Erfahrungen und Fallstricke, insbesondere im Zusammenspiel mit JSF und CDI veranschaulicht, sowie ein erstes Resümee gezogen.
http://www.opitz-consulting.com/go/3-6-11 --- Softwareentwicklung, -test und -betrieb können durch Virtualisierung viele Vorteile erzielen. In diesem Zusammenhang werden häufig Werkzeuge für die Bereitstellung von Umgebungen eingesetzt. Verschiedene Werkzeuge adressieren aber unterschiedliche Einsatzszenarien. Wo im Applikationslebenszyklus können diese Werkzeuge sinnvoll eingesetzt werden und wie sieht es mit Kosten und Nutzen aus? ---- Unser Senior Software Architect Richard Attermeyer stellte bei der W Jax am 5.11.2014 in München die Tools Vagrant, Puppet und Docker im Einzelnen vor und erläuterte ihren Nutzen anhand von Use Cases und Live Demos. ---- Weitere Infos: https://jax.de/wjax2014/sessions/vagrant-puppet-docker-fuer-entwickler-und-architekten ---- Über uns: Als führender Projektspezialist für ganzheitliche IT-Lösungen tragen wir zur Wertsteigerung der Organisationen unserer Kunden bei und bringen IT und Business in Einklang. Mit OPITZ CONSULTING als zuverlässigem Partner können sich unsere Kunden auf ihr Kerngeschäft konzentrieren und ihre Wettbewerbsvorteile nachhaltig absichern und ausbauen.---- Über unsere IT-Beratung: http://www.opitz-consulting.com/go/3-8-10 ---- Unser Leistungsangebot: http://www.opitz-consulting.com/go/3-8-874 ---- Karriere bei OPITZ CONSULTING: http://www.opitz-consulting.com/go/3-8-5
GWT wird verwendet um moderne, komplexe Rich Internet Applications zu erstellen. Durch die Generierung von JavaScript aus Java Code können alle Vorteile von Java genützt und gleichzeitig die immer größer werdenden Anforderungen der Web-Benutzer in Bezug auf Style, Performance, Interaktion und Browser-Kompatibilität von Webseiten abgedeckt werden. In dem Vortrag wird GWT vorgestellt und auf dessen Einsatz in der Praxis eingegangen.
Im Kontext von APIs kommt derzeit keiner an REST (Representational State Transfer) vorbei. REST gilt als leichtgewichtige, skalierbare und schnell erlernbare Alternative zu SOAP, die sich die vorhandene Infrastruktur des WWW zunutze macht. In der Praxis hat aber auch REST seine Schwächen. So ist gutes API-Design häufig eine Herausforderung. Für mobile Anwendungen ist REST zu starr und geht nicht effizient genug mit Bandbreite um.
Im Vortrag werden Stärken und Schwächen von REST aufgezeigt und mit GraphQL eine Alternative speziell für den mobilen Kontext vorgestellt.
Cloud Provider like AWS offer different ways to interact with their systems and to control it. One way are the typical Web UI, others are command line tools. But they also provide APIs for many programming languages. Using them many tasks can be automated, if wanted in a reactive way like Kubernetes does it in reconciliation loops.
Take a look in how this can be done with the programming language Go and as an example for AWS as cloud provider. In the end there's a hint leading to a private project for a multi-cloud provider reconciler library in Go.
Talk about the programming language Go and the feature of generics. Those have been added to the language with the version 1.18. To have more control about allowed generics Go also got type constraints as careful extension of the interfaces. Get insight into this powerful extension and how it can help you.
The document discusses moving from imperative APIs to declarative APIs. With declarative APIs, clients describe a desired state in documents rather than controlling how services execute tasks. Controllers are responsible for continuously reconciling the current state with the desired state described in documents. The approach aims to simplify distributed environments by centralizing business logic processing. Kubernetes is provided as an example of how controllers can subscribe to document changes and process reconciliations. Declarative APIs may also be useful for integrating commercial services.
This document discusses concurrency in Go and provides examples of using goroutines and channels for common concurrency patterns like background jobs, streaming data processing, and building services. It explains how goroutines allow running functions concurrently, and how typed channels enable goroutines to communicate and synchronize work through message passing. The examples demonstrate spawning goroutines, piping data between processes, and implementing a service backend that handles requests concurrently using a select statement.
Functions in Go provide a powerful, flexible and elegant way to organize code. They can be used to define simple logic, handle events and state machines, and manage concurrent processing. Functions are first-class types that can be passed around like any other value. This allows defining reusable logic through closures and implementing interfaces through anonymous functions. Combined with channels, functions enable building concurrent and asynchronous systems in a way that remains maintainable. Overall, Go's lightweight functions are a primary tool for organizing code across many domains.
Blockchains - Mehr als nur digitale WährungenFrank Müller
Eine Einführung in die Technologie der Blockchains und hier Speziell Ethereum als Chain mit Accounts und Smart Contracts, mit Whisper für das Peer-to-Peer Messaging und mit Swarm für Dateispeicherung.
Der Status von Ethereum heute sowie die Schritte für das nächste große Release und diverse Anwendungsfälle werden gezeigt.
Juju - Scalable Software with Google GoFrank Müller
The document discusses the results of a study on the effects of a new drug on memory and cognitive function in older adults. The double-blind study involved 100 participants aged 65-80 who were given either the drug or a placebo daily for 6 months. Researchers found that those who received the drug performed significantly better on memory and problem-solving tests at the end of the study compared to those who received the placebo.
RESTful Web Applications with Google GoFrank Müller
This document discusses building RESTful web applications with Google Go. It describes using Go's HTTP package to handle requests, creating a custom multiplexer to route requests based on path, defining handler interfaces to support CRUD operations, using contexts to pass request information to handlers, and marshaling data to JSON. An example shows stat, content, and tag handlers interacting to serve page and tag requests, with the stat handler asynchronously updating backend data.
Vortrag der OOP 2014
Ein Einstieg in die Software Juju für das Provisioning und die Konfiguration von Clouds sowie ein Überblick über Architekturaspekte.
An introduction into Googles programming language Go, which had its first release in March 2012. The talk has been held at the regulars' table of the GTUG Bremen.
The document discusses event-driven architecture and some of its key challenges, including how to handle latency and outages in distributed systems, how to deal with changing and temporary services, and how more complex implementations involve message-driven architectures, publish/subscribe messaging, complex event processing, and event-driven business process management. The future is envisioned to involve less monolithic applications and more dynamic compositions of internal and external services tailored to individual end users.
This document discusses agile processes and their alignment with service-oriented architectures (SOAs). It provides an introduction to agile principles and processes like extreme programming and Scrum. The key points made are:
1) Agile processes are well-suited for SOAs because they allow for flexible responses to changing requirements, continuous delivery of working software, and focus on customer satisfaction - all of which are important for services that have multiple clients.
2) Agile development supports the creation of sustainable SOA solutions through practices like continuous improvement and maintaining technical excellence - important for services that operate over long periods of time.
3) While some worry that agile only works for small teams, the document asserts that
4. • Go ist langweilig
• Go folgt keinem klaren Paradigma
• Go bietet keine esoterischen Features
• Go bietet nichts wirklich Neues
• Go ist nicht perfekt
• Go beinhaltet Stolpersteine
5. ABER
• Go ist einfach (Language Specification nur eine HTML Seite)
• Go bringt eine umfangreiche Bibliothek mit sich
• Go kompiliert sehr schnell in ein Binary
• Go beherrscht Cross-Compiling
• Go verfügt über Garbage Collection
• Go führt sehr schnell aus
• Go ist pragmatisch
8. Historie
• Start Ende 2007 aus Frust
• FAQ: „One had to choose either efficient compilation, efficient
execution, or ease of programming; all three were not available
in the same mainstream language.“
• Beginn der Entwicklung Mitte 2008
• Erste öffentliche Vorversion im November 2009
• Version 1.0 im März 2012
9. –Rob Pike
„Go aims to combine the safety and performance of a
statically typed compiled language with the
expressiveness and convenience of a dynamically typed
interpreted language.
It also aims to be suitable for modern systems – large
scale – programming.“
10. Das Team
• Rob Pike
• Ken Thompson
• Robert Griesemer
• Russ Cox
• Ian Lance Taylor
• Und weitere ...
11. Keine Unbekannten
• Ken Thompson — Multics, Unix, B, Plan 9, ed, UTF-8, etc. sowie
Turing Award
• Rob Pike — Unix, Plan 9, Inferno, Limbo, UTF-8, etc.
• Robert Griesemer — Strongtalk, Java HotSpot VM, V8
JavaScript Engine
12. Fortschritt
• 2014 wurde der der Gopher das Maskottchen von Go;
entworfen von Renée French, der Ehefrau von Rob Pike
• Alle 6 Monate erscheint ein neues Release
• Aktuell Version 1.12.5
• Versprechen der Sprachkompatibilität gleicher Hauptversionen
• Go 2 in Diskussion
14. Drei Binaries
• go — Wichtigstes Werkzeug mit vielen Subcommands
• gofmt — Einheitliche Formatierung der Go Quellen
• godoc — Generierung von Dokumentation aus Kommentaren
15. go Subcommands (Auszug)
• build — Compiling der Quellen
• fmt — Formattierung der Quellen
• get — Packages herunterladen und installieren
• install — Compiling und Installation der Quellen
• mod — Verwaltung von Modulen
• test — Durchführung der Unit Tests
• vet — Bericht über gängige Fehler
16. go mod Subcommands (Auszug)
• download — Download von Modulen in lokalen Cache
• init — Initialisierung eines Moduls im aktuellen Verzeichnis
• tidy — Bereinigung der Abhängigkeiten
• vendor — Vendorize von Abhängigkeiten
• why — Erläuterung von Abhängigkeiten
18. Orientierung in Packages
• Code immer in Packages
• Ein oder mehrere Dateien pro Package in einem Verzeichnis
• Sonderrollen
• main wird zu ausführbarem Programm
• <name>_test wird zu Unit Test von Package <name>
• Packages lassen sich hierarchisch schachteln
19. // main wird zu Programm mit dem Namen des Verzeichnisses.
package main
// Einstieg in das Programm.
func main() {
println("Hello, World!")
}
20. Import von Packages
• Import als erste Anweisung nach dem Package Statement
• Externe Packages enthalten Domain und Pfad
• Eigene Domains mit Code auf z.B. GitHub sind via Meta Tags in
einem lokalen HTML-Dokument ebenfalls möglich
• Package-Name als Präfix für Namensräume
• Alias kann gegen Namensgleichheit gesetzt werden
• Export durch Großschreibung, sonst package private
22. Funktionen
• Schlüsselwort func
• Mit Namen, anonym oder als Methode eigener Typen
• Beliebige Anzahl Parameter, letzter kann variadisch sein
• Beliebige Anzahl Rückgabewerte ohne und mit Namen
• Rückgabe mit Schlüsselwort return
23. // Mul multipliziert f mit einer beliebigen Anzahl
// Integer.
func Mul(f int, vs ...int) int {
r := f
for _, v := range vs {
r *= v
}
return r
}
24. // Div dividiert f ganzzahlig durch eine beliebige Anzahl
// Integer.
func Div(f int, vs ...int) (int, error) {
r := f
for _, v := range vs {
if v == 0 {
return 0, errors.New("division by zero")
}
r /= v
}
return r, nil
}
25. // Server ist ein Typ mit privaten Feldern.
type Server struct {
port int
...
}
// Option ist eine Funktion, die auf einem Server operiert.
type Option func(s *Server)
26. // Port liefert eine Option zum Setzen des Felds port
// zurück.
func Port(port int) Option {
return func(s *Server) {
s.port = port
}
}
27. // New erzeugt einen Server. Optionen sind ... optional. ;)
func New(opts ...Option) *Server {
s := &Server{
port: 12345, // Standardwert.
...
}
for _, opt := range opts {
opt(s)
}
return s
}
31. type StringProducer func() []string
func (sp StringProducer) Len() int {
return len(sp())
}
// Sizer definiert in meinem Package, was ich von einem
// Typ benötige.
type Sizer interface {
Len() int
}
func SizePrinter(sizer Sizer) { ... }
32. type Honk interface {
Honk() string
}
// Car bettet Honk ein, geht mit Structs und Interfaces.
type Car struct {
Honk
motor *Motor
...
}
myCar.Honk()
33. // Handler in Package net/http definiert einen Handler für
// Web Requests.
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
// ListenAndServe startet den Server mit einem Handler.
func ListenAndServe(addr string, handler Handler) error
34. // HandlerFunc vereinfach den Handler zu nur einer Funktion.
type HandlerFunc func(ResponseWriter, *Request)
// ServeHTTP implementiert den Handler und führt nur die
// Handler-Funktion aus.
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
f(w, r)
}
35. // ServeMux verteilt auf Handler nach Pfaden.
type ServeMux struct {
...
}
func (mux *ServeMux) Handle(pattern string, handler Handler) {
...
}
// ServeHTTP implementiert Handler.
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
...
}
36. Von einfachem Interface zu mehr
• Multiplexer für HTTP Methoden
• Multiplexer für Schachtelung bei RESTful APIs
• Schachtelung für Trennung von Authentisierung/Autorisierung
via JSON Web Tokens o.ä.
37. Variablen explizit und implizit
• Mit Deklaration via var oder mit Zuweisung durch :=
• Typisierung explizit oder implizit
• var kennt beides, := ist immer implizit
• Zuweisung mit =
38. var s1 string // Deklaration
s1 = "Hello" // Zuweisung
var s2 string = "World" // Explizit mit Zuweisung
var s3 = s1 + ", " + s2 // Implizit mit Zuweisung
s4 := s3 + "!" // Deklaration implizit mit
// Zuweisung
40. Bedingungen
• Mit if oder switch für logische Bedingungen
• Mit select für Channel
• switch und select kennen default an beliebiger Stelle
• break nicht notwendig
• switch verfügt über fallthrough für die Ausführung der
Folgebedingung
41. if x > y {
x, y = y, x
}
if myFunctionReturnsTrue() {
fmt.Println("Juchu!")
} else {
fmt.Println("Schade")
}
42. switch x {
case 1, 2, 3:
fmt.Println("1 bis 3")
// Verpönte Weiterverarbeitung!
fallthrough
case 4, 5, 6:
fmt.Println("4 bis 6")
default:
fmt.Println("Keine Ahnung")
}
43. // Abarbeitung von oben nach unten, aber default immer nur
// wenn nichts passt.
switch {
case x < 0:
fmt.Println("Kleiner als 0")
default:
fmt.Println("Ha! Genau 0")
case x > 0:
fmt.Println("Größer als 0")
}
44. select {
case <-ctx.Done()
return ctx.Err()
case job := <-jobs:
if err := job(); err != nil {
log.Printf("job failed: %v", err)
}
case <-time.Tick(5 * time.Second):
log.Printf("I'm waiting ...")
}
45. Schleifen
• Schlüsselwort for
• Verschiedene Formen der Bedingungen
• Vorzeitige Fortsetzung über continue
• Vorzeitiges Verlassen über break
• Label für geschachtelte Schleifen
• Arrays, Slices, Maps und Channel können mit range iteriert
werden
47. for i := 0; i < 2019; i++ {
if i % 2 == 0 {
continue
}
...
}
visitors := visitorsByConference("JAX 2019")
for i, visitor := range visitors {
fmt.Printf("Besucher %d ist %sn", i, visitor.Name)
}
49. Nebenläufigkeit
• Leichtgewichtige Funktionen (Goroutinen) im Thread Pool
• Schnelle Kontextwechsel
• Kommunikation über typisierte Channel
• Abfrage mehrerer Channel gleichzeitig über select
• Start mit Schlüsselwort go
• Gibt keine ID o.ä. zurück
50. –Rob Pike
„In programming, concurrency is the composition of
independently executing processes, while parallelism is
the simultaneous execution of (possibly related)
computations.
Concurrency is about dealing with lots of things at once.
Parallelism is about doing lots of things at once.“
52. • Einfacher Funktionsablauf im Hintergrund
• „Mach mal.“
• Dito mit Rückgabe eines Ergebnisses über einen Channel
• „Mach mal und bring mir dann das Ergebnis.“
• Kontinuierlicher Empfang zu verarbeitender Daten
• „Kümmere dich um alle meine Aufträge.“
• Dito mit serialisiertem Zugriff auf einen privaten Zustand
• „Sei mein schlauer Kollege.“
65. Aufschieben
• Funktionen können im Ablauf mit defer gestapelt werden
• Werden rückwärts beim Verlassen der umgebenden Funktion
ausgeführt
• Praktisch für Aufräumarbeiten, zum Beispiel Schließen
geöffneter Dateien
66. file, err := ioutil.TempFile("/tmp", "jax2019")
if err != nil {
return fmt.Errorf("failed to open temp file: %v", err)
}
defer file.Close()
writer := bufio.NewWriter(file)
defer writer.Flush()
writer.WriteString("JAX 2019n")
writer.WriteString("Ein Gopher im Netzn")
67. Fehlerbehandlung
• Keine Exceptions
• Fehlertyp error als letzter Rückgabewert
• Interface mit Methode Error() string
• panic() für echte Ausnahmesituationen
• Kann mit recover() aufgefangen werden
68. func CanBreakHard(x int) (err error) {
defer func() {
if r := recover(); r != nil {
err = fmt.Errorf("panic: %v", r)
}
}()
...
if veryBadCondition {
panic("have a very, yes, very, very bad condition")
}
return nil
}
75. Fast wie Scripting
• Einfache Syntax
• Leichtgewichtiges Typenmodell
• Wenige Schlüsselworte
• Schnelle Kompilation erlaubt schnelle Tests
• Aber: Manchmal mehrere Lösungswege möglich
• Nutzung etablierter Konventionen hilft
76. Einfache Nebenläufigkeit
• Prinzipiell nur Funktionen
• Flexible Kommunikation
• Weitere Hilfen zur Synchronisation
• Aber: Kein Schutz vor gleichzeitigem Zugriff auf Variablen
• Aber: Kein Schutz vor Locks und Races
• Tools helfen, ansonsten Verantwortung des Entwicklers