Browse Source

Änderungen vom 29.5.2017

master
Klaus Wendel 5 years ago
parent
commit
9c3c166650
  1. 54
      Einführung.txt
  2. BIN
      go2lgl_l08/go2lgl_l08
  3. 61
      go2lgl_l09/go2lgl_l09.go
  4. 58
      go2lgl_l09/gui/gui.go
  5. 12
      go2lgl_l09/gui/qml/formular.ui

54
Einführung.txt

@ -0,0 +1,54 @@
Sehr geehrter Herr Schnermann, sehr geehrter Herr Baumann,
gestern kam mir die Idee, hier im LGL für neugierige Entwickler eine Einführung in die Programmiersprache „Go (Golang)“ zu geben, wenn dafür Interesse besteht.
Im Rahmen eines Seminars für Studenten der Uni Stuttgart (über die Entwicklungsgeschichte von Programmiersprachen) kam ich im Sommersemester 2016 damit in Kontakt. Im Wintersemester gab ich dort einen Einführungskurs u.a. in Go.
Und seit ein paar Wochen nehme ich einen erstaunlichen Trend wahr: In den letzten sechs Wochen erhielt ich gleich vier Anfragen/Jobangebote diesbezüglich, die entweder Neuimplementierungen von Webservices und zweimal die Umstellung bestehender Webserver-Infrastruktur (weg von PHP, Java) hin zu Go zum Ziel hatten. In der freien Wildbahn scheint sich da gerade eine erhebliche Aufbruchstimmung abzuzeichnen. Ist diese Begeisterung gerechtfertigt, woran mag das liegen?
Go wird seit 2007, zunächst initiiert von Google, unter einer vollständig freien OpenSource-Lizenz entwickelt – maßgeblich von solch renommierten Informatik-Urgesteinen wie Ken Thompson, einem der Väter von UNIX!
Mich selbst faszinierte daran vor allem, daß es die Vorzüge vieler Sprachen in sich vereint: Von Java stammt die Typsicherheit, das Package-Modell und der (aus dem Code heraus regelbare) Garbage Collector, von Python übernahm es den Pragmatismus in der sehr übersichtlichen Syntax, von C erhielt es die Pointer, und hinsichtlich Performance steht die Sprache gegenwärtig auf dem Niveau von C++, sie ist auch entsprechend als Systemsprache einsetzbar.
Go ist eine auf sehr vielen Architekturen (auch ARM, z.B. für Android oder Raspberry Pi) lauffähige Compilersprache, die jedoch bei Bedarf sogar zur Laufzeit kompilieren kann. Die Sprache ist objektorientiert, allerdings verabschiedet sie sich dabei aus dem Klassen-Methoden-Korsett; es können vielmehr allen denkbaren Datentypen Methoden zugewiesen werden. Überragend ist die Sprache bei der Entwicklung nebenläufiger Programme. Die früher bei anderen Sprachen immer so fehleranfällige und sperrige Kommunikation zwischen parallel laufenden Routinen wird bei Go geradezu trivial. In diesem Punkt ist Go auch den anderen Compiler-Sprach-Neulingen wie Swift (Apple) oder dem auf ultimative Performance getrimmten Rust (von Mozilla) davongelaufen.
Es macht Spaß, sich damit zu beschäftigen, und wenn anstelle des Guten nicht noch was Besseres erfunden werden sollte, dann hat die Sprache das Potential, gleich mehrere Platzhirsche aus ihren jeweiligen Segmenten zu verdrängen. Wenn Ihrerseits Interesse besteht, dann kann ich neugierigen Kollegen gerne mal an einem Vormittag eine Einführung geben.
Herzliche Grüße und einen guten Start in den neuen Monat,
Klaus Wendel
Go ahead! - Was wird kommen, wenn Java wieder eine Insel ist?
Ist Ihnen eigentlich schon mal aufgefallen, wie lange der i5-Aufkleber schon auf Ihrem Notebook klebt? Genau, die Hardware hat sich in den letzten 10 Jahren bei weitem nicht mehr so rasant weiterentwickelt, wie wir es aus den Jahrzehnten davor gewohnt waren. Wie schon in den 1980ern muß nun Leistungssteigerung wieder mehr durch Code-Optimierung erfolgen und jetzt vor allem durch effiziente Ausnutzung nebenläufiger Rechenprozesse. Optimierung des Programmierstils ist da nur eine Facette, und die alten Limitierungen der bisherigen Programmiersprachen-Platzhirsche wie Java oder C/C++ führen entweder zu Code-Bloat oder lassen den Arbeitsaufwand stark zunehmen. Optimierung der Werkzeuge ist deswegen die andere Strategie.
Optimierung der Werkzeuge eine andere.
Rankings, Stellenausschreibungen, StackOverflow
USA Trendwende
Deutschland hinkt hinterher, aber wir in DH preschen hier nun vor.
"Nachdem die letzten beiden Jahrzehnte Programmiersprachen immer
aufgabenorienter und hardwarefremder werden ließen, hat nun mit einem
Stagnieren der Prozessorenentwicklung ein Trend eingesetzt, der bei der
Programmierung wieder mehr auf Performanz und Code-Optimierung setzt. Ganz
vorne steht hier die neue Programmiersprache Go. Sie wurde maßgeblich von
solch renommierten Informatik-Urgesteinen wie Ken Thompson (einem der
Väter von UNIX!) bei Google entwickelt und ist in den USA bereits eine
feste Größe. In Deutschland setzen Hochschulen noch immer auf das
zunehmend rückläufige Java. Wir erlangen hier also einen Vorsprung und
ergreifen die Chance, eine universelle Sprache zu erlernen, die den
Absolventen in Zukunft viele berufliche Chancen eröffnen könnte. Die
Sprache bietet zudem eine hervorragende Einführung in die relativ
maschinennahe und leistungsorientierte Programmierung von Applikationen
und Webservices. Der Kurs richtet sich an Programmieranfänger und
fortgeschrittene
Sprach-Umsteiger."
---
Heise: https://www.heise.de/developer/artikel/Go-in-Freiburg-3700556.html
Wer auf der Suche nach einer modernen Sprache ist, die sich kompilieren und statisch linken lässt, die mit einer einfachen Syntax sowie einer automatischen Speicherverwaltung aufwartet und sich gut für nebenläufige und asynchrone Programmierung eignet, landet nahezu automatisch bei Go. Go ist für viele das C des 21. Jahrhunderts. Es ist mächtig, flexibel, kennt Pointer und arbeitet systemnah, ist aber vor allem syntaktisch deutlich weiterentwickelt als C. Außerdem sind viele interessante Konzepte aus der objektorientierten Programmierung eingeflossen, so kennt Go beispielsweise Interfaces – allerdings auf eine andere Art als die üblichen OOP-Sprachen.

BIN
go2lgl_l08/go2lgl_l08

Binary file not shown.

61
go2lgl_l09/go2lgl_l09.go

@ -9,34 +9,54 @@ import (
"fmt"
"math"
"math/rand"
"os"
"runtime"
"sync"
"time"
"Präsentation3hGolang4LGLRef35/go2lgl_l09/gui"
"github.com/therecipe/qt/widgets"
)
const (
anzahlTöpfchen int8 = 35
anzahlKugeln int32 = 1000000
anzahlKugeln int32 = 80000
)
var timestamp [2]int64
var wg, wg2 sync.WaitGroup // !
var wg, wgcli, wggui sync.WaitGroup // !
func main() {
gui.SesamÖffneDich()
runtime.GOMAXPROCS(runtime.NumCPU())
timestamp[0] = time.Now().UnixNano()
var töpfchenAlle []int = make([]int, anzahlTöpfchen, anzahlTöpfchen)
var c chan bool = make(chan bool, 1)
wg2.Add(1)
//Eröffne eine neue Applikation (als eine Sammlung von Widgets)
widgets.NewQApplication(len(os.Args), os.Args)
var c_widget = widgets.NewQWidget(nil, 0)
var ui_widget = gui.LeseUIFile(c_widget)
var ui_textBrowser = gui.ErzeugeLayout(c_widget, ui_widget, &töpfchenAlle, c)
ui_textBrowser.ConnectAppend(func(s string) {
ui_textBrowser.Append(s)
})
/*
ti := time.Now()
ticker := time.NewTicker(1 * time.Second)
go func() {
for _ = range ticker.C {
ui_textBrowser.Append(strconv.Itoa(int(time.Since(ti).Seconds())))
}
}()*/
wgcli.Add(1)
go func(t *[]int, ch chan bool) {
defer wg2.Done()
defer wgcli.Done()
for true {
/* Bringt nichts, weil auf <-ch == true gewartet werden müßte:
@ -52,30 +72,35 @@ func main() {
return
default:
//guichannel <- *t
fmt.Println("\u231B", *t, runtime.NumGoroutine())
ui_textBrowser.Append(fmt.Sprint("\u231B ", *t, runtime.NumGoroutine()))
time.Sleep(time.Second * 1)
}
}
}(&töpfchenAlle, c)
for k := (int32)(1); k <= anzahlKugeln; k++ {
// Limitiere die Anzahl der go-Routinen
if rn := runtime.NumGoroutine(); rn > 50 { // !
time.Sleep(time.Millisecond * 1)
} else {
wg.Add(1)
go zeigeMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen), &töpfchenAlle)
go func(wg *sync.WaitGroup, töpfchenAlle *[]int, c chan bool) {
for k := (int32)(1); k <= anzahlKugeln; k++ {
// Limitiere die Anzahl der go-Routinen
if rn := runtime.NumGoroutine(); rn > 50 {
time.Sleep(time.Millisecond * 1)
} else {
wg.Add(1)
go zeigeMirDenGauß(int(anzahlKugeln), int(anzahlTöpfchen), töpfchenAlle)
}
}
}
wg.Wait()
c <- true
c <- true
}(&wg, &töpfchenAlle, c)
widgets.QApplication_Exec()
wg2.Wait()
wg.Wait()
wgcli.Wait()
close(c)
fmt.Println("\u2690", töpfchenAlle)
timestamp[1] = time.Now().UnixNano()
fmt.Printf("\nProzess ist fertig und hat %v Sekunden gedauert!\n\n", (float64(timestamp[1]-timestamp[0]) * math.Pow(10, -9)))
}
func zeigeMirDenGauß(anzahlKugeln int, anzahlTöpfchen int, töpfchenAlle *[]int) {

58
go2lgl_l09/gui/gui.go

@ -1,53 +1,41 @@
package gui
import (
"os"
"github.com/therecipe/qt/core"
"github.com/therecipe/qt/uitools"
"github.com/therecipe/qt/widgets"
)
func SesamÖffneDich() {
//1. Eröffne eine neue Applikation (als eine Sammlung von Widgets)
widgets.NewQApplication(len(os.Args), os.Args) // ... übergebe Kommandozeilenparameter (ansonsten "nil")
func ErzeugeLayout(widget *widgets.QWidget, formWidget *widgets.QWidget, t *[]int, ch chan bool) *widgets.QTextBrowser {
/*
var (
ui_textinputEingabefeld = widgets.NewQTextEditFromPointer(widget.FindChild("textinputEingabefeld", core.Qt__FindChildrenRecursively).Pointer())
ui_buttonAusloeser = widgets.NewQPushButtonFromPointer(widget.FindChild("buttonAusloeser", core.Qt__FindChildrenRecursively).Pointer())
)
//2. Erzeuge ein Widget
var widget = widgets.NewQWidget(nil, 0)
ui_buttonAusloeser.ConnectClicked(func(checked bool) {
widgets.QMessageBox_Information(nil, "Titel des Infofensters", ui_textinputEingabefeld.ToPlainText(), widgets.QMessageBox__Ok, widgets.QMessageBox__Ok)
})
*/
//3. Lade UI/QML (Qt Meta-object Language)-Datei und erzeuge damit indirekt
// auch das Haupt-Fenster.
var loader = uitools.NewQUiLoader(nil)
var file = core.NewQFile2("./gui/qml/formular.ui")
file.Open(core.QIODevice__ReadOnly)
var formWidget *widgets.QWidget = loader.Load(file, widget)
file.Close()
//4. Erzeuge Input-Widgets aus QML-Datei
var (
ui_textinputEingabefeld = widgets.NewQTextEditFromPointer(widget.FindChild("textinputEingabefeld", core.Qt__FindChildrenRecursively).Pointer())
ui_buttonAusloeser = widgets.NewQPushButtonFromPointer(widget.FindChild("buttonAusloeser", core.Qt__FindChildrenRecursively).Pointer())
)
var ui_textBrowser = widgets.NewQTextBrowserFromPointer(widget.FindChild("textAusgabefeld", core.Qt__FindChildrenRecursively).Pointer())
ui_textBrowser.SetText("Halo")
//5. Weise dem Knopf ein Signal zu, das beim Drücken eine Funktion ausführen soll
ui_buttonAusloeser.ConnectClicked(func(checked bool) {
widgets.QMessageBox_Information(nil, "Titel des Infofensters", ui_textinputEingabefeld.ToPlainText(), widgets.QMessageBox__Ok, widgets.QMessageBox__Ok)
})
//6. Erzeuge ein Layout und weise es dem Widget zu
var layout = widgets.NewQVBoxLayout()
//8. Weise dem Widget ein Layout zu und weise dem Layout die Input-Widges zu
widget.SetLayout(layout)
layout.AddWidget(formWidget, 0, 0)
//9. Ändere Attribute, falls nötig
widget.SetWindowTitle("Titel des Hauptfensters Nr. 2")
//10. Zeichne das Haupt-Fenster
widget.SetWindowTitle("go LGL")
widget.Show()
//11. Damit die Applikation dynamisch auf Benutzereingaben/Events reagieren
// kann, muß sie in einer Endlosschleife laufen
widgets.QApplication_Exec()
return ui_textBrowser
}
func LeseUIFile(widget *widgets.QWidget) *widgets.QWidget {
var loader = uitools.NewQUiLoader(nil)
var file = core.NewQFile2("./gui/qml/formular.ui")
file.Open(core.QIODevice__ReadOnly)
var formWidget *widgets.QWidget = loader.Load(file, widget)
file.Close()
return formWidget
}

12
go2lgl_l09/gui/qml/formular.ui

@ -6,8 +6,8 @@
<rect>
<x>0</x>
<y>0</y>
<width>394</width>
<height>620</height>
<width>1024</width>
<height>239</height>
</rect>
</property>
<property name="sizePolicy">
@ -35,9 +35,6 @@
<property name="spacing">
<number>6</number>
</property>
<item row="0" column="0" colspan="4">
<widget class="QGraphicsView" name="graphicsView"/>
</item>
<item row="1" column="0" colspan="2">
<widget class="QProgressBar" name="progressBar">
<property name="maximumSize">
@ -51,9 +48,12 @@
</property>
</widget>
</item>
<item row="1" column="3">
<item row="1" column="2">
<widget class="QLCDNumber" name="lcdNumber"/>
</item>
<item row="0" column="0" colspan="3">
<widget class="QTextBrowser" name="textAusgabefeld"/>
</item>
</layout>
</widget>
<resources/>

Loading…
Cancel
Save