Getting into IT with Grant

ChatGPT is beginning to consume my news feed.  Everywhere I look I see blog posts written by AI paired with AI generated images made by DALL-E, all headlining in news articles from the mainstream media which are probably also reviewed or distributed by AI!  It's Artificial Intelligence and Machine Learning everywhere we turn!

The rise of AI isn't bothering me as much as the trend of attributing *actual intelligence* to these robots.  In this episode, we'll discuss what is going on under the hood of ChatGPT.  We'll dive into neural networks and the various training mechanisms that are used, as well as looking at ChatGPT specifically and how it was constructed.

Along with these tools comes a lot of creative ways to use them, which we'll take a look at as well, so buckle up!  We're going to surround ourselves with robots and take a peek inside.

---

Additional resources that are mentioned in this episode:

3Blue1Brown - But what is a neural network? | Chapter 1, Deep learning

https://www.youtube.com/watch?v=aircAruvnKk

The history of chatbots

https://onlim.com/en/the-history-of-chatbots/

Okta was recently breached and some stuff was stolen by a hacker group!  Is this the end of Okta as a security provider?  You'll have to listen to find out what happened, how software exploits can work, and how to protect yourself (and your code) against them.

There are a lot of programming languages out there, so what's the difference between them and why would I choose to use one over another?  In this episode, I review the top 5 most used programming languages of 2022.  This will help clear up when these languages should be used, what they're useful for, and why they even exist in the first place!  I will talk about:

• Python
• Java
• Javascript
• C# (C-Sharp)
• C and C++ (C Plus Plus)

I've personally written a lot of code in these languages, so you won't just get a textbook knowledge from this episode.  You're going to get a whole lot of my personal opinion as well!

The world is watching Twitter become a brand new company under the leadership of Elon Musk, and in this episode I dive into the details of what has been going on!  The situation is changing from day to day, so by the time you listen to this episode new information may be available, but as of 11/22/2022 this is the story.  

This episode isn't just a "current events about Twitter" episode, though.  It also takes a look at Mastodon, one of the up and coming challengers to Twitter.  I have an account, have generated a fair amount of content on that platform, and share my experience with the ecosystem also known as the Fediverse (aka federated universe).  Mastodon is a distributed social media platform and is very interesting in its own right, even without all the craziness going on a Twitter.

My condolences to Uber on their recent hack (Sept 2022), but this does provide a great opportunity to highlight poor security practices, and share steps that companies can take so they don't fall victim to the same exploits as Uber.  In this episode we'll talk about security, as if it's an onion, do a step-by-step analysis of the Uber hack, and consider just how devastating this situation could have been if a real, malicious hacker had did exactly what this 18 year old did.

When you build a software application or product, you don't just start writing code and hope for the best!  Your code runs on a platform, typically accesses a database, and displays data to a user - all of these functions should be isolated and organized into a tech stack. 

Defining your tech stack should be one of the very first things you do, even before you write your first line of code.  Let's dig into this topic, talk about the tech stack in general and then actually define one!  We'll be using a budgeting application as our example and deciding what technologies to use in each layer of the stack.

If you feel stuck in your engineering career and are trying to break out into a different subdiscipline, then this episode is for you!  How exactly can you switch from being a Software Developer to being a Machine Learning Engineer?  Or from a Site Reliability Engineer to a Web Developer?  In this episode we will discuss how to make that transition, and how to best reflect on your current position to see why you want to transition in the first place.

-----

As discussed in the podcast, last month's episode was an article posted on my website.  Check it out here: Trunk Based Development and Continuous Integration

You work in tech and you want to be paid more money.  Great, so what's your pitch?

Have you thought about what time of day to approach your manager?  What about setting up a new meeting or using an existing one?  How about how much money to ask for?  In this episode, I dive into these topics and more so that you can craft the perfect interaction with your manager!

Do not wander into your conversation, come up with a strategy for telling your manager just how much value you deliver to the team.  Your value is what determines your pay, so think about it. 

As an added bonus, I even role-play this scenario and pretend I'm asking my boss for a raise.  If you do this well, it may pay off big for you!

-----

Robert Half Talent Solutions: Tech Salary Guides 2022

Extraneous factors in judicial decisions: PNAS

Other resources on researching your market value:
Levels.fyi
Glassdoor.com
Blind

In this episode, we'll start by separating out Agile from DevOps, and then bringing in CI/CD pipelines.  We'll also discuss DevSecOps and some of the best practices in engineering that a developer can adopt.

We'll also give an overview of what a CI/CD pipeline looks like, what a pipeline stage is, what a pipeline's purpose is, and how it is related to DevOps.  As a bonus, I talk about tools for Static Code Analysis (SCA) and Static Application Security Testing (SAST)!  We'll also touch on Test Driven Development (TDD). 

-----

Accelerate: The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations

Storytime with Dad Podcast

If you write software, you are probably collaborating with other developers.  If you are collaborating, then you probably need to isolate your code and then merge it together when you're done.  So what are some of the best-practices for managing this?

My favorite is trunk-based development, but that name probably doesn't mean what you think it means!  In this episode, we dive into branching strategies and trunk-based development.  We also touch on test automation, CI/CD pipelines, agility, and DevOps practices.  We'll also talk about anti-patterns or "worst practices" that some companies adopt because they are risk averse.  Ironically, many of today's software delivery practices increase risk rather than decrease it!

Hear my take and compare it to your own, then Tweet me (@tweetsofgrant) and tell me where our views differ!

-----

Accelerate: The Science of Lean Software and DevOps: Building and Scaling High Performing Technology Organizations

Google's Guidebook on Trunk-Based Development

Other Visualizations of Trunk-Based Development