WEEK 3: ENTRY 1

 At my internship today, I was tasked with learning Concurrency, which consists mainly of Goroutines  and Channels in the Go programming language. As mentioned in one of my previous blogs, my project would be coded in Go programming language and these two concepts are very instrumental in Go. As a result, I am currently spending time learning the language and getting familiarity with the Go codebase my team built. So what are goroutines? Unlike how the flow of processes or code lines in a conventional coding programming language like Python gets executed, goroutines are used to run different parts of the code at the same time. It is usually done with the Go keyword called go. For me, this way of writing code and calling functions  is very unfamiliar. Transitioning from Python to Go has really been a tough transition because with Python, I never had to do with running the different parts of my code base at the same time. I mostly just called the functions in the order I want the program to run. Thus, it was both a moment of awe and unfamiliarity because I used to think that all programs need to follow a sequential pattern when getting executed. This could be why most people will prefer to use Go programming rather than other programming languages because goroutines give one the avenue to execute their program in a more organized and fast way without having to worry about the fixed flow of the program. 



Another concept I learned today was Channels in Go. Perhaps, this is the most challenging Go programming concept I have come across thus far.  I have spent more than three hours trying to understand this concept. I  watched Youtube videos and read a couple of documentaries, but I am still unable to grasp it fully.  Channels are basically like pipes through which the goroutines can communicate. Sounds easy right? Well, unlike how it sounds, it is a concept that needs close look because it involves sending and receiving values, which needs to be fully understood and monitored to ensure desired results at the end. I initially went with the idea that Channels merely send and receive values. Thus, I was struck by how much more one needs to know about channels to use them well.  The basic syntax is, ch <- v, which simply means that the value of v is sent to ch. The arrow represents the direction of flow of information. But why do I find them really hard to understand if the syntax is that easy? It turns out that it involves much more than that. I am clearly lost as to why they must be defined before they are used. Also, for the channel to work, it must have a sender channel and a receiver channel. This concept baffled me at first because prior to understanding that logic, I was only creating one channel and assigning values to another variable, which never works. I realized that for a channel to work, these conditions must be satisfied: 

  1. A receiver and sender is not blocked

  2. Only a sender should close a channel, and not the receiver. 

  3. Sending on a close channel will cause a panic, which throws a deadlock error.

Overall, it was amazing to see how concurrency in Go works; however, I must say that I would have to spend another day or two to fully grasp and implement Go channels on my own. I intend to use the documentation that my manager recommended to go over this concept.

Comments

Post a Comment

Popular posts from this blog

WEEK 4: ENTRY 3

  Today at my internship, I was assigned the issue of troubleshooting why my GET request Golang code is unable to generate the data from my http server. Since it was a combination of k8s deployment and Golang go, it was trickier and harder than I envisioned. The k8s was mainly used to orchestrate the objects that are needed to generate keytab from my pods. After several debugging: comparing and contrast the referred file I used as a source code coupled with looking up the errors on Stack flow (suggested me to delete my deployment and redeployed), I was still unable to fix the issue. Partly was because I did not understand what the error message was pointing at. Thus, I had to consult a member of the k8s team, who figured out that my deployment.yaml file was missing some configurations that needed to generate my key-tab. Simply, I needed the key-tab in order to be able to make the HTTP Get Request get my desired data.   Although the recommended solution from my consultation wor...
Read more

WEEK 6: ENTRY 3

  At my internship today, I continued unmarshalling the Json data I got back from Big Query API. Having tried replicating the data on the Go playground and using the Go unmarshall function yesterday, I did develop a better understanding of the json structure. I used Go’s struct to do the unmarshalling. Unlike the json data I got from my query, the documentation’s json data does not have any schema metadata and so I thought the same approach would not work. Little did I know that the schema data can be ignored when unmarshalling json data and that you can only concentrate on the part of the Json you want to unmarshall. When I consulted my buddy, he hopped on a zoom call with me and we did pair programming. I was the driver while he was the navigator, basically explaining what we were doing because he has more knowledge on Go and Json data manipulation. Working with him gave me more skills and confidence in what I was doing. He helped in not just using the Go struct, but also in tryi...
Read more

WEEK 7: ENTRY 1

  It sometimes feels like we are not good enough when our tries don’t work. Well at my internship today, I worked on resolving the json unmarshalling issue I was stuck with last Friday. After several back-and-forth consultations with my buddy and manager, I finally got a better understanding of how they wanted me to present the data. Basically, the data should be in a simple json array that could be manipulated easier. This is because as the json comes in key:pair format, I would need to extract all the keys and use those keys to send an HTTPS request to Elasticsearch Rest API.  Even though the approach was well defined and clear to me, I still struggled to implement it using the Golang Struct and Maps. One of the obstacles I had was because after unmarshalling the json data, the output was in a Golang interface type, which was not iterable like say a slice. A Golang slice is the equivalent  of a python array. Therefore, to overcome that barrier, I created an empty slice ...
Read more