Another question came up during a recent Twitch stream that I wanted to elaborate on.
Read on for the curated 5 ways… Continue reading “Top 5 Ways to get the coding basics down!”
Read on for the curated 5 ways… Continue reading “Top 5 Ways to get the coding basics down!”
Episode Post & Video Links: 1, 2, 3, 4, 5 (this post), 6, 7, and 8. Non-linked are in the works! Videos available now on Youtube however, so check em’ out!
In this session we covered a host of topics around Go Functions. Along with some troubleshooting, debugging, and other features in Jetbrains Goland IDE.
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 as a starting point. I’m using it as a simple guideline, but also doing a lot more in each stream that includes ecosystem, dependency management with godep, IDE use of Goland from Jetbrains, and more. In this session I get specifically into: functions, signatures, declarations, recursion, return values, and more.
2:50 – Introduction to the snowy wonderland of Seattle and episode 5 of the Learning Go series. Introduction to the various screen transitions and such.
6:40 – Getting started, opening up JetBrains Goland and creating a new project. The project exists on Github as https://github.com/adron/learning-go-….
12:18 – Starting with functions in Go. See the blog entry I wrote on the topic for more additional information around this first code session within the episode 5 session.
Code – This first example I setup a basic function in Go that is called by the main function. The sample function below I’ve named exampleExecutor, and the signature is made up of an int parameter called this, a string parameter called that, and a return parameter of type int and one of type string. In summary for the function signature we have two input parameters going in and two return parameters coming out.
The function does very little besides print the parameters passed in and then return the parameters back out as the return parameters.
| package main | |
| import "fmt" | |
| func main() { | |
| var this, result int | |
| var that, message string | |
| this = 2 | |
| that = "42" | |
| result, message = exampleExecutor(this, that) | |
| fmt.Printf("%s\n%d", message, result) | |
| } | |
| func exampleExecutor(this int, that string) (int, string) { | |
| fmt.Printf("Numbers: %d, %s\n", this, that) | |
| return this, "This is the result: " + that | |
| } |
28:10 – Here I get into recursion and the application example, largely taken from the book but with some very distinctive modifications, that parses HTML and the various nodes within an HTML document.
For the recursion section I use an example from the book with an expanded sample set of HTML. The HTML is included in the repo under the function-recursion branch. For this example I setup a set of types and variables up that are needed throughout the code.
First a type setup called NodeType of type int32. A constant array of ErrorNode, TextNode, DocumentNode, ElementNode, CommentNode, and DoctypeNode for determining the different nodes within an HTML document. Then a general struct called Node with Type, Data, Attr for attribute, and FirstChild with NextSibling setup as a pointer to *Node, which gives a type of memory recursion to the underlying type. Then finally the Attribute struct with a Key a Value.
| type NodeType int32 | |
| const ( | |
| ErrorNode NodeType = iota | |
| TextNode | |
| DocumentNode | |
| ElementNode | |
| Commentnode | |
| DoctypeNode | |
| ) | |
| type Node struct { | |
| Type NodeType | |
| Data string | |
| Attr []Attribute | |
| FirstChild, NextSibling *Node | |
| } | |
| type Attribute struct { | |
| Key, Val string | |
| } |
One of the first functions I then end up with is the visit function. It turns out as shown below. Here the function takes a links parameter that is of type string array, a parameter name n that is a pointer reference to an a node within html, and then the function returns a parameter of type string array.
| func visit(links []string, n *html.Node) []string { | |
| if n.Type == html.ElementNode && n.Data == "a" { | |
| for _, a := range n.Attr { | |
| if a.Key == "href" { | |
| links = append(links, a.Val) | |
| } | |
| } | |
| } | |
| for c := n.FirstChild; c != nil; c = c.NextSibling { | |
| links = visit(links, c) | |
| } | |
| return links | |
| } |
After that function I worked through and created two additional functions, one for countsWordsAndImages and one called CountWordsAndImages. The casing being specific to scope and use of the functions, and they respectively look like this in completion.
| func CountWordsAndImages(url string) (words, images int, err error) { | |
| resp, err := http.Get(url) | |
| if err != nil { | |
| return | |
| } | |
| doc, err := html.Parse(resp.Body) | |
| resp.Body.Close() | |
| if err != nil { | |
| err = fmt.Errorf("parsing HTML: %s", err) | |
| } | |
| words, images = countWordsAndImages(doc) | |
| return | |
| } | |
| func countWordsAndImages(n *html.Node) (words, images int) { | |
| if n.Type == html.TextNode { | |
| words += len(strings.Split(n.Data, " ")) | |
| return | |
| } | |
| if n.Data == "img" { | |
| images++ | |
| } else { | |
| if n.FirstChild != nil { | |
| w, i := countWordsAndImages(n.FirstChild) | |
| words += w | |
| images += i | |
| } | |
| if n.NextSibling != nil { | |
| w, i := countWordsAndImages(n.NextSibling) | |
| words += w | |
| images += i | |
| } | |
| } | |
| return | |
| } |
Then all that is wrapped up, with recursive calls and more, in the main function for program execution.
| func main() { | |
| htmlContent, err := ioutil.ReadFile("compositecode.html") | |
| if err != nil { | |
| fmt.Println(err) | |
| } | |
| htmlData := string(htmlContent) | |
| r := strings.NewReader(htmlData) | |
| doc, err := html.Parse(r) | |
| if err != nil { | |
| fmt.Fprintf(os.Stderr, "find links: %v\n", err) | |
| os.Exit(1) | |
| } | |
| for _, link := range visit(nil, doc) { | |
| fmt.Println(link) | |
| } | |
| w, i, _ := CountWordsAndImages("https://compositecode.blog") | |
| fmt.Printf("Words: %d\nImages: %d\n", w, i) | |
| } |
1:32:40 – At this point in the episode 5 session I get into a simple Error handling function, and further into function signatures and how to set them up.
1:52:24 – Setting up some anonymous functions and reviewing what they are.
1:59:00 – Introduction to panics in Go. After this short introduction I also discuss some of the pedantic specifics of methods vs functions and related verbiage around the Go language. Additionally I provide more examples around these specifics for declaring functions, various scope, and other types for function calls and related usage.
With that done the wrap up of the session is then a short introduction to anonymous functions.
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]) |
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])) |
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 | |
| } |
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 | |
| } |
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 | |
| } |
That’s it for this synopsis. Until next episode, happy code thrashing and go coding!
First, I’ve got a few observations that I’ve made in the last 6 months since joining DataStax (which I joined ~10 months ago) about a number of things. In this post I’ve detailed some of the thoughts, observations, and ideas I have about many of the aspects, roles, divisions, organizational structure, and related elements of DevRel.
Over the last few months a lot of moments and conversations have come up in regards to DevRel being under the marketing department within an organizational structure. Which has made me revisit the question of, “what is DevRel and what do we do again?” Just asking that question in a free form and open ended way brings up a number of answers and thoughts around what various DevRel teams and even groups within a DevRel team may have as a mission. Let’s break some of this out and just think through the definition. Some of the other groups that DevRel either includes or works very closely with I’ll include too.
At the core of DevRel, somewhere, is the notion of advocacy to the developer. This advocacy comes with an implied notion that the advocates will bring solid technical details. These details then are brought to engineering and in many cases even contribute in some technical way to production advancement and development. Does this always happen among advocates, the sad honest answer is no, but that’s for another blog entry. At this point let’s work with the simple definition that Developer Relation’s Advocates work from a technical point of view to bring product and practice to developers in the community. Then take the experience gained from those interactions and learning what the community of developers is working on back to engineering and product to help in development of product and in turn, messaging. To be clear, I’ve broken this out again just for emphasis:
“Advocates work from a technical point of view to bring product and practice to developers in the community. Then take the experience gained from those interactions and learning what the community of developers is working on back to engineering and product to help in development of product and in turn, messaging.”
I feel, even with that wordy definition there are a few key words. For one, when I write community in this definition I have a specific and inclusive context in which I use the word. It includes customers, but also very specifically includes non-customers, users of similar competing products, prospective customers, and overall anybody that has some interest in the product or related topics of the product. In addition to this, product needs clearly scoped in this definition. Product means, for example in the case of the Spring Framework. Product wouldn’t stop at the finite focus on just Spring and it’s code base and built framework product, it would also include how that framework interacts with or does not interact with other products. It would include a need for at least a passing familiarity, and ability to dive in deeper if questions come up, into peripheral technology around the full ecosystem of the Spring Framework.
If there’s any other part of that definition that doesn’t make sense, I’d be curious what you think. Is it a good definition? Does adding specific details around the words used help? If you’ve got thoughts on the matter I’d love your thoughts, observations, ideas, and especially any opinions and hot takes!
Curriculum Mission: How to Effectively Learn and Share Product Knowledge
Often a developer relations team either includes, might be part of, or otherwise organized closely with curriculum development. Curriculum development, the creative and regimented process of determine how to present material to learn and teach about the product and product ecosystem is extremely important. Unless you’re selling an easy button, almost every practical product or service on the planet needs at least some educational material rolled into it. We all start with no knowledge on a topic at some point, and this team’s goal is to bring a new learner from zero knowledge to well versed in the best way possible. Advocates or dedicated teachers may be tasked with providing this material, sometimes it’s organized a slightly different way, but whatever the case it’s extremely important to understand what is happening with curriculum.
Let’s take the curriculum team at DataStax for example. They build material to provide a pathway for our workshops, all day teaching sessions, the DataStax Academy material and more. Sometimes the advocates jump in and help organize material, sometimes engineers, and others. They do a solid job, and I’m extremely thankful for their support. It gives the teachers, which in many cases it’s us advocates, a path to go without the overhead of determining that path.
However…
It is still extremely important, just like with the advocates’ roles of bringing community feedback to engineering in an effective way, we need to bring student feedback and ideas to increase the curriculum effectiveness back to the curriculum team itself. As we teach, and learn at the same time, we find new ways to present information and new ways to help students try out and experiment with concepts and ideas. Thus, again, advocates are perfectly aligned with the task of communicating between two groups. Ensuring that this communication is effective as well as curriculum material is one of the many core skills for developer advocates.
In the next post on this topic of refining, defining, and learning about the best way for DevRel to operate here’s some topic thoughts:
I hope to get to these posts, or maybe others will write a thing or three about these? Either way, if you write a post let me know, if you’d like me to write about a specific topic also let me know. I’ll tackle it ASAP or we can discuss whatever comes up in this realm.
This is by no means the end of this topic, just a few observations and all. I’ll have more, but for now this is what I got done and hope to contribute more in the coming days, weeks, months, and years to this topic. DevRel – good effective, entertaining, and useful DevRel – is one of my keen interests in industry. Give me a follow, and I’ll have more of these DevRel lessons learned, observations, and ideas that I’d love to share with you all and also get your feedback on.
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) | |
| } |
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)*cos30*xyscale | |
| sy := height/2 + (x+y)*sin30*xyscale – 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) | |
| } |
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
You must be logged in to post a comment.