Send us a text

Episode 04: Show Notes

This week we talk about the 5th on the series of blog entries from the Developers and Practitioners big: Avoiding GCF anti-patterns part 5: How to run background processes correctly in Python.

This post identifies problems where python code calls standard libraries to put processing in the background. While this is a common practice in data centers or on the developer’s box, in a server less environment this does not work correctly.

If there is a need to have processing separate from the main thread of execution, you should use tools such a Cloud Tasks to spin off the processing.

Key Points From This Episode:

• Code is executing in a sandbox, not a machine. Forks don’t work the way you expect
• Rather than break off threads to execute, use more instantiations of the code, or hand off execution to another Cloud Function via Cloud Tasks
• Make sure you are doing code reviews to catch problems like this early
• Some speculation on the upcoming AWS re:Invent.

Send us a text

Don't make promises you can't keep - Using Node.ja promises correctly in Google Cloud functions

Episode 03: Show Notes

(Recorded November 18, 2021)

Today Jon and Logan discuss the recent Google Cloud blog “Avoiding GCF anti-patterns part 4: How to handle Promises correctly in your Node.js Cloud Function”, and give their own views on how to go about this. They discuss the scenario outlined in the blog, the two patterns that the blog outlines for fixing this issue, and the origins of their own biases regarding JavaScript, before explaining their own solution to this problem using TypeScript. They also explain how this issue differs from the one they discussed in the last episode ans the importance of code not just running reliably but also being readable and maintainable. Tune in to find out why Jon and Logan are biased towards taking the clouding approach to developing this code, why you should look in the DataFlow if you’re doing an ETL pipeline, why you should reconsider deploying a system based on vanilla node.js, and what you should do if you decide to do it anyway.

Key Points From This Episode:

• Recent news: The Google outage that occurred this week. 
• Today’s topic: the blog post “Avoiding GCF anti-patterns part 4: How to handle Promises correctly in your Node.js Cloud Function”
• An introduction to the scenario outlined in this blog post. 
• Jon’s biases based on his experiences with JavaScript and its evolution. (And Jon’s embarrassing memory lapse re: AJAX)
• The two patterns for fixing this issue outlined in the blog post. 
• The rest of the blog: How to write some methods for logging and integrate those into logic that’s doing the promise database call and retrieval. 
• Jon and Logan’s bias: Why are you making an asynchronous call to a database?
• How this issue differs from the one they discussed in the last episode about how to deal with API calls that could take a long time.
• Promises, their role in JavaScript, and the problem of them being conflated with “vettable” code.
• The importance of code not just running reliably but being readable and maintainable.
• Logan’s solution to this problem using TypeScript.
• Understanding the context of this code in the browser context. 
• Why Jon and Logan are biased towards taking the cloudy approach to developing this code.
• Why you should look in the data flow if you’re doing an ETL pipeline.
• Why you should reconsider deploying a system based on node.js and what you should do if you decide to do it anyway.

Tweetables:

“Writing code that’s difficult to understand, difficult to read, difficult to maintain, you are definitely doing a disservice to your future self or whoever’s in that role in the future.” — @LoganAct2 [0:12:34]

“Be lazy, be cheap. Let the infrastructure help you catch the bugs early with something like TypeScript and collect the bugs in a central place with the Cloud Operations capability ” — @JonGal [0:14:41]

Links Mentioned in Today’s Episode:

Avoiding GCF anti-patterns part 4: How to handle Promises correctly in your Node.js Cloud Function

Typescript Reference

DataFlow

Send us a text

Avoiding Being Dumb

Episode 2: Show Notes

(Recorded November 4, 2021)

Welcome to episode two of the Cloud Out Loud Podcast! Today, Jon and Logan discuss a couple of blog posts; one from Corey Quinn, Chief Cloud Economist at The Duckbill Group and creator of the Last Week in AWS newsletter, which shares some very valuable insights into where cloud providers should be going in terms of introducing people to the cloud and training people about the cloud. The second is titled ‘Avoiding GCF Anti-Patterns Part 3: How to establish outbound connections correctly’, the third in a GCP Blog series on Google Cloud Function (GCF) anti-patterns, which tackles two common issues you might encounter in your monitoring and logging when making outbound HTTP requests with a GCF and how to solve them. We tease out the common thread between both these blog posts, which echoes the overall theme of this podcast: what are the cultural changes that need to occur to take advantage of the cloud and be more effective? The cloud can bring enormous benefit to your applications, to your programming workflow, but it does require mindset change!

Key Points From This Episode:

• Diving into ‘The Dumbest Dollars a Cloud Provider Can Make’ by Corey Quinn.
• How charging for training disincentivizes people from learning about cloud platforms.
• Why Jon believes that cloud providers should provide free training and pay trainers.
• Calling for training and certification to be loss leaders for cloud platforms.
• The benefits of introducing limited time offers without diminishing the value of training.
• Next: ‘Avoiding GCF Anti-Patterns Part 3: How to establish outbound connections correctly’.
• Two common problems that arise: increased error messages and expired execution times.
• How to solve for a lower error rate or lower latency, depending on your use case.
• Using Cloud Tasks or PubSub to offload your requests to another cloud service.
• Jon on the highly technical aspects of this post versus appealing to Cloud Function newbies.
• How to break up the monolithic approach that traditional developers tend to take.
• What Corey Quinn’s post and the GCP Blog post have in common: adopt not only new skills and knowledge, but new mindsets and culture too!
• The ability and responsibility developers have to leverage the power of managed services.
• Final thoughts: the cloud is powerful and, like all powerful things, treat it like a chainsaw!
• Updates from the world of Web 3.0, the Metaverse, and NFTs.

Tweetables:

“Charging people for training and not paying trainers would be chasing after pennies and ignoring dollars.” — @JonGal  [0:03:27]

“The revenue that you may be gaining by charging for the [training] as a cloud provider is pretty small compared to the benefits that training can bring to driving future revenue for the cloud with organizations that are receiving the training.” — @LoganAct2  [0:04:57]

“Between increased error rates and increased latency, a common pattern for improving the performance of your Cloud Functions is to offload your requests to another cloud service.” — @LoganAct2 [0:09:33]

“The world is different in the cloud. Not only do you have to acquire new skills and knowledge, you have to acquire new [mindsets], possibly new [cultures] within your company.” — @JonGal [0:13:27]

Links Mentioned in Today’s Episode:

Send us a text

Reviewing What Not to do with Google Cloud Functions and Cloud Run

Episode 1: Show Notes.

(Recorded October 28, 2021)

Welcome to the very first installment of Cloud Out Loud! For our first show, we catch up on some recent news, including our thoughts on Facebook’s ambitious plans for their new metaverse and its accompanying data requirements. Next, we dive into our main topic, namely some of the new developments regarding Google Cloud Functions and Google Cloud Run. We take a look at recent blog posts from Google Cloud Next and discuss what they reveal about data storage and the future of Google Functions and Google Cloud Run. Our conversation also touches on Google’s presence in the cloud and data space, how they measure up against other behemoths like Amazon and Facebook, and why the way Google approaches storage through a system called Colossus is profoundly different from other players in the field. We wrap up our discussion with some thoughts on web three along with a sneak peek into future episodes. For all this and much more, tune in today!

Key Points From This Episode:

• A recap of the news of the week including an update on Cloud Next and our thoughts on some of the product announcements.
• Facebook’s ambitious metaverse and its accompanying data challenges.
• The two blog posts that Google released about Cloud Functions.
• How these blog posts inform a discussion on Cloud Functions versus Cloud Run.
• The two blog posts on avoiding GCF anti-patterns.
• How to write event-driven Cloud Functions properly by coding with idempotency in mind.
• How to reuse Cloud Function instances for future invocations.
• The trade-off between speed of execution, running out of memory, and unintentionally bloating yourself. 
• The convergences between Cloud Functions and Cloud Run.
• Some of the separate use cases for these two products.
• Our predictions for Cloud Functions and Cloud Run remaining separate products.
• Some quick thoughts and opinions from our hosts on web three.

Tweetables:

“The way Google stores things through a system called Colossus is profoundly different from everybody else. And Google had to develop this Colossus because they encountered huge amounts of data early on.” — @JonGal [0:05:03]

“We do see some convergence with Cloud Functions and Cloud Run. But they still are, I believe, separate use cases for these two products…” — @LoganAct2 [0:20:29]

Links Mentioned in Today’s Episode:

The Paper Jeff Barr tweeted about

Google Cloud Functions

Google Cloud Run

Google Cloud Next

Avoiding GCF anti-patterns part 1: How to write event-driven Cloud Functions properly by coding with idempotency in mind

Avoiding GCF anti-patterns part 2: How to reuse Cloud Function instances for future invocations

BigQ

Send us a text

What To Expect From This Podcast with Logan and Jon Gallagher

Episode 0: Show Notes.

(Re-Recorded January 6, 2022)

Welcome to the very first episode of Cloud Out Loud, a podcast hosted by Jon and Logan Gallagher that reviews cloud computing trends from the lens of humans and culture. Gone are the days when hosting a production server meant building racks and starting an on-premise data center. The cloud has opened up the possibility for unlimited computing, storage, and networking. While this is incredible, it also means we have developed a tool that we don’t fully understand the capacity of yet! The revolutionary nature of the cloud points to the fact that profound shifts need to be made culturally within organizations in order to take advantage of it. Suddenly, decisions need to consider storage, networking, computing, and security, which heralds the end of siloing. It is with considerations like this in mind that we decided to launch Cloud Out Loud. We are really excited about this project and look forward to going on this journey with you in all the future episodes!

Key Points From This Episode:

• Introducing listeners to ourselves and what we aim to achieve with this show.
• The experience Logan has in the cloud space, and of the needs of users and developers.
• Jon’s background in cloud architecture and perspectives on how revolutionary it is.
• Stating our intention to review developments in the cloud and focus on Google and AWS.
• Educating companies about the changes they need to make based on how revolutionary the cloud is.
• How the cloud necessitates that decisions consider storage, networking, computing, and security.
• Our aim: To look at developments in the cloud through the lens of humans and culture.
• How the abstraction provided by the cloud allows us to wrestle with different questions like privacy. 

Tweetables:

“I have gotten to touch a lot of different areas of the cloud space as well as multiple different cloud platforms, seeing their strengths, weaknesses, and where the real potential is.” — @loganact2 [0:01:30]

“Our experience in using the cloud and the capabilities of the cloud point us to the fact that we are opening up a tool that we don’t know the potential of yet.” — @JonGal [0:03:40]

“You are going to hear us talk about this a lot. What are the cultural adaptations and changes that need to be made in order to truly take advantage of the cloud?” — @JonGal [0:04:58]

“Humans and culture are going to be a big lens through which we view many cloud news stories and events.” — @loganact2 [0:05:09]

Links Mentioned in Today’s Episode:

Logan Gallagher on Twitter

Logan Gallagher on LinkedIn

Jon Gallagher on Twitter

Jon Gallagher on LinkedIn

Nube De Helado