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.
Perl - die Taschenkettensäge unter den Programmiersprachen - Vortrag 2003Brigitte Jellinek
Vorstellung der Programmiersprache Perl auf drei Ebenen: für Programmier-Anfänger, für Fortgechrittene und für Profis. inkl. Buchtipps zu Perl.
Ein Vortrag den ich ursprünglich am Chaos Communication Congress 2000 in Berlin gehalten habe, hier in der Version von 2003.
der aktuelle Stand Perl 5.20 an features und Kultur: beeinflusst von Perl 6 wird an den wesentlichen Stellen aufgeräumt: dies war das Update für den Linuxtag in Chemnitz März 2015
IT-Tage 2021: Java to Go - Google Go für Java-Entwickler Jan Stamer
Die Programmiersprache Go ist angesagt – und das zu Recht. Populäre Projekte wie Kubernetes, Docker oder Terraform zeigen, dass Go bestens geeignet ist, um moderne Anwendungen für die Cloud zu entwickeln. Aber was macht Go interessant für Java-Entwickler? Go ist durch und durch auf Nebenläufigkeit und Parallelisierung ausgelegt. Außerdem hat Go ein statisches Typsystem und ist rasend schnell. Aber vor allem: Go macht Spaß.
In dieser Session lernt Ihr die Sprache Go mit ihren Stärken und Schwächen aus Sicht eines Java Entwicklers kennen. Ihr bekommt einen sehr praxisbezogenen Einstieg, HandsOn anhand von kleinen Projekt Beispielen.
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.
Im Rahmen der Developer Konferenz des Internet-Briefing zeige ich Last- und Performancetests mit Proxy Sniffer (http://www.proxy-sniffer.com/).
Die Präsentation dient dabei als Einleitung und Begleitung. Die Demo ist hier kurz zusammengefasst: http://www.youtube.com/watch?v=kP7ZxGTBync
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
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?
Perl - die Taschenkettensäge unter den Programmiersprachen - Vortrag 2003Brigitte Jellinek
Vorstellung der Programmiersprache Perl auf drei Ebenen: für Programmier-Anfänger, für Fortgechrittene und für Profis. inkl. Buchtipps zu Perl.
Ein Vortrag den ich ursprünglich am Chaos Communication Congress 2000 in Berlin gehalten habe, hier in der Version von 2003.
der aktuelle Stand Perl 5.20 an features und Kultur: beeinflusst von Perl 6 wird an den wesentlichen Stellen aufgeräumt: dies war das Update für den Linuxtag in Chemnitz März 2015
IT-Tage 2021: Java to Go - Google Go für Java-Entwickler Jan Stamer
Die Programmiersprache Go ist angesagt – und das zu Recht. Populäre Projekte wie Kubernetes, Docker oder Terraform zeigen, dass Go bestens geeignet ist, um moderne Anwendungen für die Cloud zu entwickeln. Aber was macht Go interessant für Java-Entwickler? Go ist durch und durch auf Nebenläufigkeit und Parallelisierung ausgelegt. Außerdem hat Go ein statisches Typsystem und ist rasend schnell. Aber vor allem: Go macht Spaß.
In dieser Session lernt Ihr die Sprache Go mit ihren Stärken und Schwächen aus Sicht eines Java Entwicklers kennen. Ihr bekommt einen sehr praxisbezogenen Einstieg, HandsOn anhand von kleinen Projekt Beispielen.
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.
Im Rahmen der Developer Konferenz des Internet-Briefing zeige ich Last- und Performancetests mit Proxy Sniffer (http://www.proxy-sniffer.com/).
Die Präsentation dient dabei als Einleitung und Begleitung. Die Demo ist hier kurz zusammengefasst: http://www.youtube.com/watch?v=kP7ZxGTBync
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
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?
The Lotus Code Cookbook - Ulrich Krause
Tipps, Tipps, Tipps ... Die Session behandelt kein zentrales Thema. In loser Folge werden Tipps und Tricks aus allen Bereichen der Programmierung in Lotus Notes / Domino vorgestellt. @Formula, LotusScript, Java, JavaScript, LS2CApi.
Zielgruppe sind Alle, die sich mit Applikationsentwicklung beschäftigen. Anfänger und "alte Hasen"; es ist für jeden etwas dabei.
Mit WebDirect kann man wieder mehr Plugins einsetzen auf dem Server. Da bietet es sich doch an eventuell ein eigenes Plugin zu bauen für Schnittstellen. Per Plugin etwas schneller machen, auf Betriebssystemfunktionen zugreifen oder das Plugin als Schnittstelle zu einer C Bibliothek nehmen, die etwas wichtiges macht. Wir schauen uns die Vorraussetzungen an, das Plugin SDK und wie man eigene Funktionen definiert. In der Demo bauen wir ein Plugin selbst und probieren es gleich mal aus.
Slides of my talk at PHP USERGROUP DRESDEN on 29.06.2016 bei Collab & Couch
* Example-Source-Code: https://github.com/PHPinDD/phar-better-tool-example
* Example-Distribution: https://github.com/PHPinDD/phar-better-tool-distribution
Wie erstelle ich Webapplikationen mit Node.js. Vorgestellt werden verschiedene Frameworks wie Express.js oder Koa. Außerdem wird auf Skalierung eingegangen.
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.
Go ist die Sprache Nummer 1 für cloudnative Entwicklung. Der Beweis: 19 von 25 Projekten der Cloud Native Computing Foundation im höchsten Reifegrad nutzen Go, darunter Kubernetes und Docker. Aber was macht Go interessant für Java oder .NET-Entwickler? Go ist durch und durch auf Nebenläufigkeit und Parallelisierung ausgelegt. Außerdem hat Go ein statisches Typsystem, eine moderne, mächtige Standardbibliothek und ist rasend schnell. Aber vor allem: Go macht Spaß. Mit einfachen praktischen Beispielen lernt ihr mit Go produktiv zu entwickeln. Wir beginnen mit dem Hello World. Dann ein kleines Kommandozeilen Tool und eine einfache Webanwendung. Dazu nutzen wir überwiegend die Standardbibliothek von Go. Ihr lernt wesentliche Konzepte von Go wie Interfaces, Goroutinen und Channels kennen. Zur Entwicklung nutzen wir die Go-Tools und eine moderne Entwicklungsumgebung. Nach unserem Workshop könnt ihr erste eigene Go-Anwendungen entwickeln. Und ihr seid bereit die nächsten Schritte mit Go zu gehen. Go ist eine Sprache für Macher. Also lasst uns machen!
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
Websites, die stark frequentiert werden, sollten in jedem Augenblick optimale Ladezeiten für den Besucher aufweisen. Kommt PHP als objektorientierte Interpreter- Sprache zum Einsatz, muss besonderes Know How mitgebracht werden. Dieser Artikel gibt einen
Überblick über die Performance-Maßnahmen, -Methoden, -Produkten und -Werkzeugen in der PHP- rogrammierung.
Eine kleiner Reminder... PHP 5.3 und seine neuen Features. Im Rahmen dieser Veranstaltung konnte bei weitem nicht alles genannt werden, was die neue Version anbietet. Diese Session zeigte an Hand von konkreten Beispielen die Anwendung einiger dieser Features.
PHP Usergroup Rheinhessen,
Session vom 2010-04-06
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
3. Go Erfahrung
• Artikel, Buch, Talks, Kolumne rund um Go
seit 2010
• Seit 2011 professionelle Nutzung
• Cloud Provisioning
• Microservices in der Logistik
• Ethereum Messaging
• Kubernetes Cluster Management
• OSS unter dem Label Tideland
5. Kurzeinführung
• 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
6. 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
Kurzeinführung
7. ❝
It’s better to have a permanent income than to be
fascinating.
Oscar Wilde
9. 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
10. ❝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.
Rob Pike
11. Das Team
• Rob Pike
• Ken Thompson
• Robert Griesemer
• Russ Cox
• Ian Lance Taylor
• Und weitere ...
12. 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
13. 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.14.1
• Versprechen der Sprachkompatibilität
gleicher Hauptversionen
• Go 2 in Diskussion
15. Drei Binaries
• go — Wichtigstes Werkzeug mit vielen
Subcommands
• gofmt — Einheitliche Formatierung der Go
Quellen
• godoc — Generierung von Dokumentation
aus Kommentaren
16. 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
17. 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
19. 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
20. Package main
!// main wird zu Programm mit dem Namen des Verzeichnisses
!// oder einem per Argument bestimmten Namen.
package main
!// Einstieg in das Programm.
func main() {
println("Hello, World!")
}
21. Import von Packages
• Import direkt nach dem Package Statement
• Externe Packages mit 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
• Aliase bei Namensgleichheit möglich
• Export durch Großschreibung, sonst package
private
23. 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
24. Definition einer einfachen Funktion
!// 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
}
25. Funktion mit Ergebnis und Fehler
!// 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
}
26. Optionen als Funktionen 1/3
!// 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)
27. Optionen als Funktionen 2/3
!// Port liefert eine Option zum Setzen des Felds port
!// zurück.
func Port(port int) Option {
return func(s *Server) {
s.port = port
}
}
28. Optionen als Funktionen 3/3
!// 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
}
32. Methoden und Interfaces
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) { !!... }
33. Einbetten von Typen
type Honker interface {
Honk() string
}
!// Car bettet Honker ein, geht mit Structs und Interfaces.
type Car struct {
Honker
motor *Motor
!!...
}
myCar.Honk()
34. Flexibilität durch Interfaces
!// 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
35. Funktionstypen erlauben Methoden
!// 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)
}
36. Weitere Implementierungen
!// 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) {
!!...
}
37. Vom einfachem Interface zu Lösungen
• Multiplexer für HTTP Methoden
• Multiplexer für Schachtelung bei RESTful
APIs
• Schachtelung für Trennung von
Authentisierung/Autorisierung via JSON Web
Tokens o.ä.
38. Variablen explizit und implizit
• Mit Deklaration via var oder mit Zuweisung
durch :=
• Typisierung explizit oder implizit
• var kennt beides, := ist immer implizit
• Zuweisung mit =
39. Unterschiedliche Zuweisungen
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
41. 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
42. Verzweigung mit if
if x > y {
x, y = y, x
}
if myFunctionReturnsTrue() {
fmt.Println("Juchu!")
} else {
fmt.Println("Schade")
}
43. Verzweigung mit switch
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")
}
44. Verzweigung mit Bedingungen
!// 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")
}
45. Channel-Verzweigung mit select
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 !!...")
}
46. 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
48. Schleifen 2/2
for i !:= 0; i < 2019; i!++ {
if i % 2 !== 0 {
continue
}
!!...
}
visitors !:= visitorsByWebinar("Devs@Home")
for i, visitor !:= range visitors {
fmt.Printf("Besucher %d ist %sn", i, visitor.Name)
}
50. 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 Instanz oder ID zurück
51. ❝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.
Rob Pike
53. Typische Varianten von Goroutinen
• „Mach mal.“
• „Mach mal und bring mir dann das Ergebnis.“
• „Kümmere dich um alle meine Aufträge.“
• „Sei mein schlauer Kollege.“
61. Einfacher Taschenrechner
type Op func()
!// Calc ist ein Taschenrechner mit einem Wert als Zustand.
type Calc struct {
cancel context.CancelFunc
ops chan Op
value float64
}
62. Konstruktion des Rechners
func New(ctx cancel.Context) *Calc {
c !:= &Calc{
ops: make(chan Op, 1),
value: 0.0,
}
ctx, c.cancel = context.WithCancel(ctx)
go c.backend(ctx)
return c
}
69. Volle Kanäle 2/5
• Nicht wie bei OOP überschneidender Zugriff
• Serialisierung eingehender Nachrichten
• Synchrone Zugriffe werden blockiert, Queues
laufen voll und blockieren ebenso
70. Volle Kanäle 3/5
• Last möglichst beim Aufrufer belassen
• Zentrale Goroutine zur Datenverwaltung
• Weitere Last und Daten auf Arbeits-
Goroutinen verteilen
• Mutex / RWMutex in Go können helfen
71. Volle Kanäle 4/5
Client Server
DoThis()
Data()
API
return data
SetData()
Work()
Client Goroutine
74. Race Conditions 2/4
• Überlagerndes Lesen und Setzen
• Update durch Delta mit Rückgabe des neuen
Wertes
• Alternativ Rückgabe des Wertes mit Handle
für Aktualisierung
78. Nicht-atomare Veränderungen 2/3
• Auslöser sind zu granuläre Nachrichten und
nicht eingehaltene Protokolle
• Zusammenhängende Daten gleichzeitig
ändern beziehungsweise auslesen
80. Blockaden durch Cycles 1/3
Goroutine A Goroutine B
Goroutine C
Foo()
Bar()
Yadda()
return
return
81. Blockaden durch Cycles 2/3
• Auslöser sind synchrone Abfragen
• Timeouts zeigen Blockaden auf, vermeiden
jedoch nicht den Fehler
• Bei zwingender Abhängigkeit Design auf
Basis asynchroner Kommunikation
• Zustandsänderungen in den Prozessen
müssen dies berücksichtigen
82. Blockaden durch Cycles 3/3
Goroutine A Goroutine B
Goroutine C
Foo(1)
Bar(1)
Yadda(1)
SetBar(1)
SetFoo(1)
SetYadda(1)
84. 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
85. Mehrere gestapelte Aufräumer
file, err !:= ioutil.TempFile("/tmp", "webinar-*")
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("Webinar Devs@Homen")
writer.WriteString("Einführung in Gon")
86. Fehlerbehandlung
• Keine Exceptions
• Fehlertyp error als letzter Rückgabewert
• Interface mit Methode Error() string
• Helfer im Package errors
• panic() für echte Ausnahmesituationen
• Kann mit recover() aufgefangen werden
87. Paniken auffangen
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
}
94. 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
95. 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