Schedule Updates: Coding, Meetups, Twitch Streams, Etc.

Here is my updated schedule for the two weeks starting August 12th for my Twitch streams, the basic topics, meetups (a little beyond two weeks), and related events coming up.

Series: Thrashing Code General Calamity

This is going to be a mix of tech this week. Probably some database hacking, code hacking, samples, and setup of even more examples for use throughout your coding week!

August 16th @ 3:33pm

Series: Meetups

This is a little further out than the next few weeks, but in August we’re having another meetup!

Wednesday, August 21st, 2019 New event oriented language and framework: Charlie Green and Charles Sullivan (Meetup Link)

Series: Emerald City Tech Conversations

Join me and several guests, on several different days to get into particulars about programming, coding, hacking, ops, devops, or whatever comes up. Ask questions, inquire, infer, or inform we’re here for the conversation. Join my guests and I!

Series: DataStax’s Apache Cassandra & C# Hour (C# Schema Migration builder, C# driver, and additional content). Navigate through to the DataStax Developers Channel to check out the event times.

The regularly occurring DataStax Devs series are continuing too, so join me, Cristina, Eric, and others on the team for these episodes and more. Check out the channel here!

Schedule Updates: Databases, Coding, Meetups, & More

Here is my updated schedule for the two weeks starting the 23rd for my Twitch streams, the basic topics, meetups (a little beyond two weeks), and related events coming up.

Series: Thrashing Code General Calamity

This is going to be a mix of tech this week. Probably some database hacking, code hacking, samples, and setup of even more examples for use throughout your coding week!

Series: Bunches of Databases in Bunches of Weeks

Focusing on DataStax Enterprise setup and configuration over the next few weeks.

Series: Meetups

This is a little further out than the next few weeks, but in August we’re having another meetup!

Series: Building the Geo App Trux (w/ Vue.js, Go, and DataStax Enterprise (Apache Cassandra). Navigate through to the DataStax Developers Channel to check out the event times.

Series: DataStax’s Apache Cassandra & C# Hour (C# Schema Migration builder, C# driver, and additional content). Navigate through to the DataStax Developers Channel to check out the event times.

Learning Go Episode 4 – Composite Types, Slices, Arrays, Etc.

Episode Post & Video Links: 1, 2, 3, 4 (this post), 5, 6, 7, and 8. Non-linked are in the works! Videos available now on Youtube however, so check em’ out!

If you’d like to go through this material too in book form, I highly suggest “The Go Programming Language” by Alan A.A. Donovan & Brian W. Kernighan. I use it throughout these sessions to provide a guideline. I however add a bunch of other material about IDE’s, development tips n’ tricks and other material.

8:00 Starting the core content with some notes. Composite types, arrays, slices, etc.
11:40 Announcement of my first reload – http://compositecode.blog/2019/02/11/… – second successful time blogged here) of the XPS 15 I have, which – https://youtu.be/f0z1chi4v1Q – actually ended in catastrophe the first time!
14:08 Starting the project for this session.
16:48 Setting up arrays, the things that could be confusing, and setup of our first code for the day. I work through assignment, creation, new vs. comparison, and various other characteristics of working with arrays during this time.

	fmt.Println("Hello, let's talk composite types.")

	basketOfStuff := [3]string{"The first string","second","This string."}
	var zeeValues [2]int

	for i, v := range basketOfStuff {
	fmt.Printf("Value %d: %s\n", i, v)
	}

	fmt.Println(zeeValues)

	if zeeValues[0] == zeeValues[1] {
	fmt.Println("The values are the same, this doesn't instantiate like the `new` keyword.")
	} else {
	fmt.Println("The way go appears to instantiate unset variable values, such as in this array is like the `new` keyword instantiation.")
	}

	zeeValues[0] = 1 + 52 * 3
	zeeValues[1] = 9

	fmt.Println(zeeValues[len(zeeValues) – 1])

view raw

testing-out-composite-types.go

hosted with ❤ by GitHub

29:36 Creation of a type, called Currency, of type int, setting up constants, and using this kind of like an enumerator to work with code that reads cleaner. Plus of course, all the various things that you might want to, or need for a setup of types, ints, and related composite types like this.

	type Currency int

	const (
	USD Currency = iota
	CAN
	EUR
	GBP
	JPY
	NOK
	SEK
	DKK
	)

	symbol := […]string{USD: "$", CAN: "$", EUR: "€", GBP: "£", JPY:"¥", NOK:"kr", SEK:"kr",DKK:"kr"}

	fmt.Println(EUR, symbol[EUR])

	fmt.Println(JPY, symbol[JPY])

	r := […]int{99: -1}

	r[36] = 425
	r[42] = 42

	fmt.Println(r[36] + r[42])
	fmt.Println(strconv.Itoa(r[36]))

view raw

currency.go

hosted with ❤ by GitHub

43:48 Creating an example directly from the aforementioned book enumerating the months of the year. This is a great example I just had to work through it a bit for an example.

	months := […]string{1: "January", 2:"February", 3: "March", 4:"April", 12:"December"}

	for _, s := range months {
	fmt.Printf("The month: %s\n", s)
	}

	var runes []rune
	for _, r := range "Language: 走" {
	runes = append(runes, r)
	}
	fmt.Printf("%q \n", runes)

	var x, y []int
	for i := 0; i < 10; i++ {
	y = appendInt(x, i)
	fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
	x = y
	}

view raw

the_months.go

hosted with ❤ by GitHub

52:40 Here I start showing, and in the process, doing some learning of my own about runes. I wasn’t really familiar with them before digging in just now!

	… the rest of the main.go file is here…


	var runes []rune
	for _, r := range "Language: 走" {
	runes = append(runes, r)
	}
	fmt.Printf("%q \n", runes)

	var x, y []int
	for i := 0; i < 10; i++ {
	y = appendInt(x, i)
	fmt.Printf("%d cap=%d\t%v\n", i, cap(y), y)
	x = y
	}

	}

	func appendInt(x []int, i int) []int {
	var z []int
	zlen := len(x) + 1
	if zlen <= cap(x) {
	z = x[:zlen]
	} else {
	zcap := zlen
	if zcap < 2* len(x) {
	zcap = 2 * len(x)
	}
	z = make([]int, zlen, zcap)
	copy(z, x)
	}

	return z
	}

view raw

main.go

hosted with ❤ by GitHub

1:09:40 Here I break things down and start a new branch for some additional examples. I also derail off into some other things about meetups and such for a short bit. Skip to the next code bits at the next time point.
1:23:58 From here on to the remainder of the video I work through a few examples of how to setup maps, how make works, and related coding around how to retrieve, set, and otherwise manipulate the maps one you’ve got them.

	package main

	import "fmt"

	func main() {
	ages := map[string]int{
	"Peterson": 52,
	"Sally": 22,
	"Javovia": 15,
	"Ben": 42,
	}

	jobAssociation := make(map[string]string)
	jobAssociation["Peterson"] = "Engineer"
	jobAssociation["Sally"] = "CEO"
	jobAssociation["Jovovia"] = "Gamer"
	jobAssociation["Ben"] = "Programmer"

	printAges(ages)
	printJobAssociations(jobAssociation)

	fmt.Println(ages)
	fmt.Println(jobAssociation)
	fmt.Println(jobAssociation["Jovovia"])
	fmt.Println(jobAssociation["Frank"]) // Blank! 😮
	fmt.Println(ages["Sally"])

	delete(ages, "Sally")

	fmt.Println(ages)
	fmt.Println(ages["Sally"])

	delete(jobAssociation, "Jovovia")

	fmt.Println(jobAssociation)
	fmt.Println(jobAssociation["Jovovia"]) // Blank.

	ages2 := map[string]int{
	"Frank": 52,
	"Johnson": 22,
	"Smith": 15,
	"Jezebelle": 42,
	}

	ages3 := map[string]int{
	"Frank": 52,
	"Johnson": 22,
	"Smith": 15,
	"Jezebelle": 42,
	}

	if equal(ages, ages2) {
	fmt.Println("Naw, not really equal.")
	} else {
	fmt.Println("This is correct, not equal.")
	}

	if equal(ages2, ages3) {
	fmt.Println("True, these are effectively the same map values and keys.")
	}
	}

	func printJobAssociations(associations map[string]string) {
	for name, job := range associations {
	fmt.Printf("%s\t%s\n", name, job)
	}
	}

	func printAges(ages map[string]int) {
	for name, age := range ages {
	fmt.Printf("%s\t%d\n", name, age)
	}
	}

	func equal(x, y map[string]int) bool {
	if len(x) != len(y) {
	return false
	}
	for k, xv := range x {
	if yv, ok := y[k]; !ok \|\| yv != xv {
	return false
	}
	}
	return true
	}

view raw

map_types.go

hosted with ❤ by GitHub

That’s it for this synopsis. Until next episode, happy code thrashing and go coding!

Learning Go Episode 3 – More Data Types, Casting, Rendering an SVG file, and writing to Files.

Episode Post & Video Links: 1, 2, 3 (this post), 4, 5, 6, 7, and 8. Non-linked are in the works! Videos available now on Youtube however, so check em’ out!

Episode 3 of my recurring “Learning Go” Saturday stream really got more into the particulars of Go data types including integers, strings, more string formatting verbs, concatenation, type casting, and lots of other pedantic details. In the episode I also delve into some OBS details with the audience, and we get the Twitch interface I’ve setup a bit more streamlined for easier readability. Overall, I think it’s looking much better than just the last episode! Hats off to the conversational assist from the audience.

Here’s the play by play of what was covered in episode 3 with the code in gists plus the repo is available on Github. Video below the timeline.

Timeline

0:00 Intro
6:08 The point I fix the sound. Just skip that first bit!
6:24 Re-introducing the book I’m using as a kind of curriculum guide for these go learning sessions.
7:44 Quick fix of the VM, a few updates, discussion of Goland updates, and fixing the Material Theme to a more visually less caustic theme. Also showing where it is in the IDE.
9:52 Getting into the learning flow, starting a new project with Go 1.11.4 using the Goland IDE new project dialog.

	package main

	import (
	"fmt"
	"math"
	"strconv"
	)

	func main() {
	var someInt int
	var anotherValue int64
	thisValue := 45
	thisVAlue, thatValue, someValue := 20, 23, 15
	someInt = thisVAlue
	anotherValue = 64

	const knownSet = 7.12904
	const anotherKnown = 9.10347

	for x := 0; x < 20; x++ {
	fmt.Printf("x = %d e = %8.3f\n", x, math.Exp(float64(x)))
	}

	fmt.Printf("Known Set and Another Known: %2.7f, %2.7f", knownSet, anotherKnown)

	fmt.Printf("The values: %6d, %6d, %6d, and %s.\n", thisValue, thisVAlue, thatValue, strconv.Itoa(someValue))
	fmt.Printf("Other values: %4d, %4d.\n", someInt, anotherValue)

	fmt.Printf("Function doThings: %6d\n", doThings(thisVAlue, thisValue))
	fmt.Printf("Function doMoreThings: %s", doMoreThings(someInt, int(anotherValue), "Adron"))
	}

	func doThings (valueOne int, valueTwo int) int64 {
	result := valueOne * valueTwo
	return int64(result)
	}

	func doMoreThings (valueOne int, valueTwo int, name string) string {
	result := valueTwo + valueOne * 10
	return "The result added and exponentially multiplied for you " + name + " this: " + strconv.Itoa(result)
	}

view raw

main.go

hosted with ❤ by GitHub

10:50 Creating the Github repo for learning-go-episode-3.
12:14 Setting up the initial project and CODING! Finally getting into some coding. It takes a while when we do it from nothing like this, but it’s a fundamentally important part of starting a project!
13:04 From nothing, creating the core basic elements of a code file for go with main.go. In this part I start showing the various ways to declare types, such as int and int64 with options on style.
14:14 Taking a look at printing out the various values of the variables using formatter verbs via the fmt.Printf function.
17:00 Looking at converting values from one type to another type. There are a number of ways to do this in Go.

I also, just recently, posted a quick spot video and code (blog entry + code) on getting the minimum and maximum value in Go for a number of types. This isn’t the course video, just a quick spot. Keep reading for the main episode below.

18:16 Oh dear the mouse falls on the ground. The ongoing battle of streaming, falling objects! But yeah, I get into adding a function – one of the earlier functions being built in the series – and we add a signature with a return int64 value. I continue, with addition of another function and looking at specifics of the signature.
25:50 Build this code and take a look at the results. At this point, some of the formatting is goofed up so I take a look into the formatter verbs to figure out what should be used for the output formatting.
33:40 I change a few things and take a look at more output from the various calculations that I’ve made, showing how various int, int64, and related calculations can be seen.
37:10 Adding a constant, what it is, and when and where and why to declare something as a constant.
38:05 Writing out another for loop for output results of sets.
42:40 A little git work to create a branch, update the .gitignore, and push the content to github. Repo is here btw: https://github.com/Adron/learning-go-episode-3

At this point I had to take a short interruption to get my ssh keys setup for this particular VM so I could push the code! I snagged just a snippet of the video and made a quick spot video out of it too. Seems a useful thing to do.

47:44 Have to add a new ssh key for the virtual machine to github, so this is a good little snippet of a video showing how that is done.
56:38 Building out a rendering of an SVG file to build a graphic. The complete snippet is below, watch the video for more details, troubleshooting, and working through additions and refactoring of the code.

	package main

	import (
	"fmt"
	"io/ioutil"
	"math"
	"strconv"
	)

	const (
	width, height = 600, 600
	cells = 100
	xyrange = 30.0
	xyscale = width / 2 / xyrange
	zscale = height * 0.4
	angle = math.Pi / 6
	)

	var sin30, cos30 = math.Sin(angle), math.Cos(angle)

	func main() {

	var outputResult string

	outputResult = "<svg xmlns='http://www.w3.org/2000/svg' " +
	"style='stroke: blue; fill: white; stroke-width: 0.7' " +
	"width='" + strconv.Itoa(width) + "' height='" + strconv.Itoa(height) + "'>"

	for i := 0; i < cells; i++ {
	for j := 0; j < cells; j++ {
	ax, ay := corner(i+1, j)
	bx, by := corner(i, j)
	cx, cy := corner(i, j+1)
	dx, dy := corner(i+1, j+1)

	outputResult = outputResult + "<polygon points='" +
	ax + "," + ay +
	bx + "," + by +
	cx + "," + cy +
	dx + "," + dy +
	"'/>\n"
	}
	}
	outputResult = outputResult + "</svg>"
	fmt.Printf(outputResult)
	err := ioutil.WriteFile("surface-plot.svg", []byte(outputResult), 0644)
	if err != nil {
	fmt.Printf("Error: %s", err)
	}
	}

	func corner(i, j int) (string, string) {
	x := xyrange * (float64(i)/cells – 0.5)
	y := xyrange * (float64(j)/cells – 0.5)

	z := f(x, y)

	sx := width/2 + (x-y)cos30xyscale
	sy := height/2 + (x+y)sin30xyscale – z*zscale

	xResult := strconv.FormatFloat(sx, 'f', -1, 64)
	yResult := strconv.FormatFloat(sy, 'f', -1, 64)
	return xResult, yResult
	}

	func f(x, y float64) float64 {
	r := math.Hypot(x, y)
	return math.Sin(r)
	}

view raw

main.go

hosted with ❤ by GitHub

1:15:32 We begin the mission of bumping up the font size in Goland. It’s a little tricky but we get it figured out.
1:33:20 Upon realization, we need to modify for our work, that this outputs directly to a file instead of just the console. Things will work better that way so I work into the code a write out to file.
1:40:05 Through this process of changing it to output to file, I have to work through additional string conversions, refactoring, and more. There’s a lot of nuance and various things to learn during this section of the video, albeit a little slow. i.e. LOTS of strconv usage.
2:01:24 First view of the generated SVG file! Yay! Oh dear!
2:09:10 More troubleshooting to try and figure out where the math problem is!
2:22:50 Wrapping up with the math a little off kilter, but sort of fixed, I move on to getting a look into the build but also pushing each of the respective branches on github. Repo is here btw: https://github.com/Adron/learning-go-episode-3

Category: Video

Schedule Updates: Coding, Meetups, Twitch Streams, Etc.

Series: Thrashing Code General Calamity

Series: Meetups

Series: Emerald City Tech Conversations

Like this:

Schedule Updates: Databases, Coding, Meetups, & More

Series: Thrashing Code General Calamity

Series: Bunches of Databases in Bunches of Weeks

Series: Meetups

Like this:

Learning Go Episode 4 – Composite Types, Slices, Arrays, Etc.

Like this:

Learning Go Episode 3 – More Data Types, Casting, Rendering an SVG file, and writing to Files.

Like this:

Series: Thrashing Code General Calamity

Series: Meetups

Series: Emerald City Tech Conversations

Share this:

Like this:

Series: Thrashing Code General Calamity

Series: Bunches of Databases in Bunches of Weeks

Series: Meetups

Share this:

Like this:

Share this:

Like this:

Share this:

Like this:

Share this:

Like this: