Forem: Greg Fullard

Learn AWS with me :: Episode 5 : S3

Greg Fullard — Tue, 12 Jan 2021 07:52:39 +0000

Background

Welcome to Episode 5 of the Learn AWS series. The purpose behind this series is to build skills and confidence in using the AWS platform, by finding, testing and sharing the best learning resources that teach specific AWS services AS WELL AS the various foundational technologies they depend on. In short: Instead of writing a tutorial that just scratches the surface, we assemble together a learning path of resources to help you towards real mastery.

You can learn more about the series here: https://dev.to/gregfullard/learn-aws-with-me-episode-1-introduction-mph

Episode 5 focusses on AWS S3. Let's get into it..

Introduction

Amazon S3 is a highly scalable, secure and performance object storage service that forms the backbone of many AWS solutions. But why is it called "Object Storage" when we actually store files on S3? Well, that's because there are key differences between the "Object Storage" and "File Storage" approached. In particular, object storage does not utilize a hierarchical structure to manage the location of files. Instead, each piece of data is bundled with all it's relevant data and then given a unique id for retrieval. This approach makes it much easier to scale storage beyond the capabilities of traditional file Storage.

Due to the wide variety of use cases for storage, S3 includes many different storage tiers that offer different performance and reliability characteristics.

Getting Started with AWS S3

Getting started with S3 is super simple, and the best place is probably to simply follow the getting started tutorials offered in the Amazon docs: https://docs.aws.amazon.com/AmazonS3/latest/gsg/GetStartedWithS3.html

Your starting point is being able to create buckets, upload and download objects, and configure object permissions. Once those bases are covered, it's time to dig a little deeper.

Simplilearn has a solid introductory video as part of their AWS Tutorial for beginners: https://www.youtube.com/watch?v=XGcoeEyt2UM

Core Concepts in S3

There are many core concepts in S3, and becoming a master requires familiarity with:

Block Storage vs File Storage vs Object Storage
Storage Classes
- Standard
- Intelligent Tiering
- Standard IA (Infrequent Access)
- One Zone IA
- Glacier
- Deep Archive
LifeCycle Policies
Versioning
Cross-region Replication
Object Locking
Access Points
Metadata
Access Policies
- Resource Based Policies
- User Based Policies
ACLs (Access Control Lists)
Block Public Access
Encryption
- Server-side encryption
- Client-side encryption
Event Notifications

The S3 Deep Dive course provides a thorough explanation of most of the concepts listed above. You can sign-up and complete the course for free here: https://www.aws.training/Details/Curriculum?id=26930

Tools in S3

AWS provides a number of handy tools that allow you to analyse your S3 usage for cost and performance optimization. These include:

Access Analyser
S3 Inventory Report
S3 Storage Lens

Foundational Skills for working with S3

No technology lives in isolation, and S3 is no different. Although you can begin your learning journey by jumping straight into S3, becoming a true master will require skills and experience in the prerequisite, complementary and alternative technologies. The following Skills Tetris diagram gives a simple overview of the skills neighborhood that S3 lives in.

Beyond the console

Once you've worked through the resources above, you should be quite comfortable working with S3 via the AWS console. But in real life, you may also need to interact with ACM via the AWS CLI or one of the available SDKs. I like the Boto3 (Python) SDK quite a lot, so the two resources I used often were:

Next Steps

This blog article covered the most important aspects that I came across during the weekly Twitter thread, but if you're interested, you can check out the original thread here: https://twitter.com/devskilldojo/status/1338381598174146562

Next up (Episode 6) is a Kata, where we will get the opportunity to practice some of the skills we've learnt so far.

Learn AWS with me :: Episode 4 : Route 53

Greg Fullard — Mon, 14 Dec 2020 07:50:44 +0000

Background

Welcome to Episode 4 of the Learn AWS series. The purpose behind this series is to build skills and confidence in using the AWS platform, by finding, testing and sharing the best learning resources that teach specific AWS services AS WELL AS the various foundational technologies they depend on. In short: Instead of writing a tutorial that just scratches the surface, we assemble a learning path of great existing resources to help you towards mastery.

You can learn more about the series here: https://dev.to/gregfullard/learn-aws-with-me-episode-1-introduction-mph

Episode 4 focuses on AWS Route 53. Let's get into it..

Introduction

Route 53 is a DNS web service that can be used for domain registration, DNS routing, and a range of related health checks. If, like me, you're the type of person who registers a new domain for every business idea that enters your mind, then you are quite familiar with the concept of domain registrars. You would also be familiar with the idea that once you register a domain with your provider (for example, GoDaddy), they give you an admin interface for working with the DNS records of that domain.

What you may not know (I certainly did not), is that there is a distinct difference between a Domain Registrar and a DNS provider. It just so happens that most domain registrars include a free (but quite limited) DNS service with their domain registration package.

Route 53 makes the distinction between the domain registration and the DNS service very explicit, even though they also offer both services. Once you wrap your head around that distinction, the value of Route 53 becomes very clear.

Getting Started with AWS Route 53

The first thing that you'll notice when you open the Route 53 console, is that there is a lot going on: Hosted zones, traffic policies, domains, resolvers, etc. Quite a lot to take in, and it's difficult to know where exactly to start. The simplest place is to just register a new domain on Route 53. Yes, it costs a few bucks, but the cost is on par with any other provider.

Note: Route 53 does charge an extra $0.50 per month for the DNS service though, so be aware.

The process for registering a new domain is dead simple. If you've done it at any other provider, you'll be fine. If not, you can refer to the developer guide: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/domain-register.html

If you want to transfer a domain from another service provider to Route 53, the process is a bit more complicated. In essence you first create a hosted zone on Route 53 and then update the name servers at your existing provider. Once this is done, the transfer of the domain registration is a simple (but possibly time consuming) process. The process is described here: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/domain-transfer-to-route-53.html

While the Name Server update process is happening, you will be able to verify your Domain details (Including the current active NS records) in the official WHOIS database. This is easily done at https://lookup.icann.org.

IMHO the best introduction to Route 53 is probably the re:Invent 2016 session titled "DNS Demystified". It's well worth the time spent. Here's the link: https://www.youtube.com/watch?v=AAq-DDbFiIE

Once you've got the basics of DNS and Route 53 covered, it is important to explore the various routing policies and their use cases. This is really where Route 53 becomes a powerhouse in your solution architecture (and where it justifies the monthly DNS fees you will have to pay). Here are the resources related to routing policies that I found valuable:

General routing info in the AWS Developer Guide: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/routing-policy.html
@BePythoholic has a handy video explaining each of the routing policies: https://www.youtube.com/watch?v=9CsIB2ewCjc
Details about setting up failover routing in the AWS Developer Guide: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/dns-failover.html

And finally, after I played with Route 53 a bit, I also found the follow-up presentation at re:Invent 2017 very valuable. It builds on the session from 2016 and tied things into a nice bow for me: https://www.youtube.com/watch?v=PVBC1gb78r8

Core Concepts in Route 53

When working with Route 53, there are a number of core concepts to be familiar with, including Domain Registrars, DNS services, Hosted zones, TTL and much more. Luckily the documentation team put together this handy reference, which I would strongly recommend: https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/route-53-concepts.html

Foundational Skills for working with Route 53

No technology lives in isolation, and Route 53 is no different. Although you can begin your learning journey by jumping straight into Route 53, becoming a true master will require skills and experience in the prerequisite, complementary and alternative technologies. The following Skills Tetris diagram gives a simple overview of the skills neighborhood that Route 53 lives in.

DNS

Since Route 53 is a DNS service, we need to build a good understanding of DNS. I've referred people to this concise (and entertaining) introduction by @spiceworks many times before, so let's start there: https://www.youtube.com/watch?v=dE4rsNuG0aw

These two articles (one from Medium and one from Digital Ocean) also provide a great introduction to DNS:

Reliability Engineering

You DON'T need to be versed on all aspects of reliability engineering before you touch Route 53, but many of the capabilities that Route 53 provides are geared towards addressing reliability concerns. In particular: Consistent health checks, elegant failover management, and low latency data transfer. You can begin your exploration of reliability engineering on the Wikipedia page (https://en.wikipedia.org/wiki/Reliability_engineering). Beware! The rabbit hole is deep :)

Beyond the console

Once you've worked through the resources above, you should be quite comfortable creating and configuring your DNS routing with Route 53 via the AWS console. But another important strength of Route 53 is that you can interact with it via the AWS CLI or one of the available SDKs. I like the Boto3 (Python) SDK quite a lot, so the two resources I used often were:

Things I struggled with

Although Route 53 is very powerful, it isn't particularly complex, so I didn't get stuck too much. However, the process for transferring a domain from one of my existing providers was quite tedious on the first attempt. When I moved over a second domain things made more sense.

Things I would still need to figure out

I specifically didn't look at private DNS capability yet, since this isn't an immediate requirement for me. Additionally, I'd want to play around with Traffic Flow at some stage.

Resources I uncovered in the process

During my Route 53 learning journey I uncovered many useful learning resources. Some have been listed above already, but for completeness, here is a complete list of the resources I used:

Handy overview of DNS by Spiceworks: https://www.youtube.com/watch?v=dE4rsNuG0aw
Great overview of DNS concepts by Digital Ocean: https://www.digitalocean.com/community/tutorials/an-introduction-to-dns-terminology-components-and-concepts
Demystifying DNS article by Ayush Gupta: https://medium.com/@ayushkgupta007/demystifying-dns-3fb936940c76
"DNS Demystified" session at re:Invent 2016 (NET202): https://www.youtube.com/watch?v=AAq-DDbFiIE
"DNS Demystified" session at re:Invent 2017 (NET302): https://www.youtube.com/watch?v=PVBC1gb78r8
Pythoholic's free YouTube course on AWS: https://www.youtube.com/playlist?list=PLiH9_MU-6RjI9gdFqmvUfKRfw_zRxIb6o
DNS Design Using Amazon Route 53 - AWS Online Tech Talks: https://www.youtube.com/watch?v=2y_RBjDkRgY
SimpliLearn's AWS Tutorial Videos for beginners: https://www.youtube.com/playlist?list=PLEiEAq2VkUULlNtIFhEQHo8gacvme35rz
Route 53 Masterclass by Rohan Arora: https://www.youtube.com/watch?v=FxLtEnrb84M
FreeCodeCamp AWS Solutions Architect course (https://www.youtube.com/watch?v=Ia-UEYYR44s)
Stephane Maarek's AWS Solution Architect Associate course on Udemy: https://www.udemy.com/course/aws-certified-solutions-architect-associate-saa-c02

Next Steps

Next up (Episode 5) is S3, you can follow along with episode 5 on this Twitter thread: https://twitter.com/devskilldojo/status/1338381598174146562

Learn AWS with me :: Episode 3 : AWS Certificate Manager

Greg Fullard — Mon, 07 Dec 2020 07:38:25 +0000

Background

Welcome to Episode 3 of the Learn AWS series. The purpose behind this series is to build skills and confidence in using the AWS platform, by finding, testing and sharing the best learning resources that teach specific AWS services AS WELL AS the various foundational technologies they depend on. In short: Instead of writing a tutorial that just scratches the surface, we assemble together a learning path of great existing resources to help you towards mastery.

You can learn more about the series here: https://dev.to/gregfullard/learn-aws-with-me-episode-1-introduction-mph

Episode 3 focuses on AWS Certificate Manager. Let's get into it..

Introduction

A number of AWS services allow/require you to configure details of an SSL/TLS certificate. Instead of uploading cert files directly, these services reference the centralised store of certs managed under ACM. The services that reference ACM include CloudFront, Elastic Load Balancing, API Gateway and others (The full list can be found here: https://docs.aws.amazon.com/acm/latest/userguide/acm-services.html)

ACM makes it possible to import your existing TLS certificates for use on the AWS platform, but it also provides a simple process for creating new certificates. When creating certificates with ACM, it is important to realise that ACM is not a general certificate service like "Let's Encrypt" (or many of the for-profit alternatives). Instead, certificates created on ACM can only be used on integrated AWS services.

Getting some prerequisite knowledge established:

Before getting into the nuts and bolts of ACM, it is important to have a baseline knowledge of TLS. This article by @GeekflareHQ provides a comprehensive, but beginner-friendly introduction: SSL/TLS 101 for Beginners https://geekflare.com/tls-101/

A critical aspect to understand about TLS certificates is the different levels of validation that they provide. The levels are: Domain Validation, Organization Validation and Extended Validation. This page from the SSL Store gives a nice summary: https://www.thesslstore.com/new-to-ssl/ssl-authentication-levels.aspx

Certificates issued by ACM are Domain Validation Certificates

Getting Started with AWS Certificate Manager

Assuming you already have an AWS account created, the best/fastest place to start your ACM journey is by issuing a new certificate for one of the domains you control. The AWS user guide probably offers the best step-by-step instructions: https://docs.aws.amazon.com/acm/latest/userguide/gs-acm-request-public.html

There are two possible approaches to validate your domain: Email-based, or DNS-based. Depending on your situation you should pick the easiest one for you. In my case, DNS was the way the go. I issued a number of certificates for domains from multiple providers and I can confirm that the exact process varies quite a bit between different providers.

You can also easily import existing TLS certificates into ACM. To test this out, I used the https://zerossl.com website to generate a cert, which I could then import and use on ACM. Take note: if you import your own certs, you will have to take responsibility for managing expiry and replacement, while ACM-issued certs are automatically renewed.

Core Concepts in ACM

When working with ACM, it is essential to understand a number of core concepts:

PKI (Public Key Infrastructure)
Certificate Authority
Certificate Signing Request
Certificate
Key
etc.

The AWS ACM User Guide includes a handy reference page the lists (and describes) key concepts related to ACM. Definitely worth a few minutes of your time: https://docs.aws.amazon.com/acm/latest/userguide/acm-concepts.html

Foundational Skills for working with ACM

No technology lives in isolation, and ACM is no different. Although you can begin your learning journey by jumping straight into ACM, becoming a true master will require skills and experience in the prerequisite, complementary and alternative technologies. The following Skills Tetris diagram gives a simple overview of the skills neighbourhood that ACM lives in.

Beyond the console

Once you've worked through the resources above, you should be quite comfortable creating and importing ACM certs via the AWS console. But in real life, you may also need to interact with ACM via the AWS CLI or one of the available SDKs. I like the Boto3 (Python) SDK quite a lot, so the two resources I used often were:

Things I struggled with

Different DNS providers have very different interfaces for specifying CNAME records, which caused some confusion for me. Also, they replicate those records are different rates. Neither of these were major issues though.

Things I would still need to figure out

I did notice that ACM also provides the ability to define a private CA, which would be used when an enterprise needs to issue internal certs. I did not use this functionality at all.

Next Steps

Next up (Episode 4) is Route 53, you can follow along with episode 4 on this Twitter thread: https://twitter.com/devskilldojo/status/1335841066210250752

Learn AWS with me :: Episode 2 : CloudFront

Greg Fullard — Sun, 29 Nov 2020 17:16:50 +0000

Background

Welcome to Episode 2 of the Learn AWS with me series. The purpose behind this series is to build skills and confidence in using the AWS platform, by finding, testing and sharing the best learning resources that teach specific AWS services AS WELL AS the various foundational technologies they depend on. In short: Instead of writing a tutorial that just scratches the surface, we assemble together a learning path of great existing resources to help you towards mastery.

You can learn more about the series here: https://dev.to/gregfullard/learn-aws-with-me-episode-1-introduction-mph

Episode 2 focusses on AWS CloudFront. Let's get into it..

Introduction

CloudFront is a CDN (Content Delivery Network) that allows us to deploy applications at AWS Edge locations to ensure low latency.

But what exactly is a CDN?

Well, it's a widely distributed network of servers that allows your content to be deployed near the end user. This makes it faster for content to get to your users. Some well known CDNs that you might come across include Akamai, Cloudflare and Fastly. Of course the major cloud providers all have their own as well: AWS CloudFront, Google Cloud CDN, Azure CDN, etc. As always, Wikipedia has a nice introduction: https://en.wikipedia.org/wiki/Content_delivery_network

Getting Started with AWS CloudFront

Assuming you already have an AWS account created, the best/fastest place to start your CloudFront journey is with the AWS getting started tutorial: https://aws.amazon.com/getting-started/hands-on/deliver-content-faster/

For some more simple and practical steps on how to use CloudFront with S3 to host a simple static website, you could also check out this article on FreeCodeCamp by @colbyfayock : https://www.freecodecamp.org/news/how-to-host-and-deploy-a-static-website-or-jamstack-app-to-s3-and-cloudfront/

Serving up static S3 content via CloudFront is great, but that's not where it's usefulness ends. This 10 Minutes tutorial from David Brown is a great introduction into using CloudFront with dynamic content served from load balanced EC2 instances: https://youtu.be/V8vR7rA0ubs

Core Concepts in CloudFront

When working with CloudFront, it is essential to understand the following core concepts:

Object: The content that is served and cached (An image, web page, etc.)
Origin: Source where the original object is served from
POP (Point of Presence): The edge servers closest to the end user
Regional Cache: A longer term cache that sits between the POP and the Origin
Distribution: A specification for how your content should be distributed to make delivery to end users efficient

Foundational Skills for working with CloudFront

No technology lives in isolation, and CloudFront is no different. Although you can begin your learning journey by jumping straight into CloudFront, becoming a true master will require skills and experience in the prerequisite, complementary and alternative technologies. The following "Skills Tetris Diagram" gives a simple overview of the skills neighbourhood that CloudFront lives in.

DNS

Since CloudFront closely relates to HTTP routing, a baseline understanding of DNS is helpful. No need to be a DNS expert, a cursory understanding is all you need. Here's a great video for a start: https://www.youtube.com/watch?v=dE4rsNuG0aw

After you've created a CloudFront distribution, your site will be accessible at a URL that was randomly generated under the CloudFront domain. For example "d3mkvdtexdirhr.cloudfront.net". This is fine for testing, but to link your distribution to a custom domain, you need to configure a CNAME record. There are many sources that provide an overview of DNS records. Cloudflare has a concise explanation on CNAME records at https://www.cloudflare.com/en-gb/learning/dns/dns-records/dns-cname-record/

While debugging DNS issues I found this article which explains some command line tools that are quite valuable: https://www.cloudns.net/blog/dns-tools-dns-trace-online-ping-traceroute-dns-lookup-reverse-lookup/

HTTP Caching

CloudFront makes your site faster by employing various caching strategies. To build a solid grasp of HTTP Caching, you can't do much better that this @MozDevNet page: https://developer.mozilla.org/en-US/docs/Web/HTTP/Caching

SSL /TLS

When adding a custom domain CNAME to your CloudFront distribution, you need to supply a valid TLS certificate. Which means you need some level of understanding of TLS. This article by Steve Cope does a great job at explaining the fundamentals: http://www.steves-internet-guide.com/ssl-certificates-explained/

Setting up a TLS certificate will depend on where you get the certificate and where your domain is hosted. For me, I'm using GoDaddy and issued the certificate via AWS Certificate Manager. I used this article by @cingulara for reference: https://medium.com/@dale.bingham_30375/creating-a-static-website-using-godaddy-github-aws-s3-codedeploy-and-aws-cloudfront-1990a8f4ddd8

Beyond the console

Once you've worked through the resources above, you should be quite comfortable configuring CloudFront distributions for most typical websites via the AWS console. But in real life, you are much more likely to interact with CloudFront via the AWS CLI or one of the available SDKs. I like the Boto3 (Python) SDK quite a lot, so the two resources I used often were:

Things I struggled with

Using LetsEncrypt instead of Amazon Certificate Manager

I wanted to use Let's Encrypt CertBot and Certbot-s3front to generate a TLS certificate. I ran into various issues, specifically with the Certbot-s3front tool. Eventually I gave up and used ACM instead, which was pretty painless.

ACM Email verification

ACM Email verification didn't work for me, because the domain I used doesn't have any email hosting attached and the administrator email address is flagged as private on the WHOIS database, which meant that AWS never sent me a mail. When I switched to DNS validation it worked well

Root domain redirect to AWS CloudFront

Getting my root domain to redirect to AWS was not intuitive with GoDaddy, but once you know how to achieve it, it's quite simple (Don't use DNS records, but rather use the Domain redirect function on GoDaddy)

Things I would still need to figure out

Since I only spent a couple of hours per day for 5 days, I couldn't deep dive into everything that CloudFront offers. Some other capabilities I'd like to explore on a future iteration include:

How to cache some parts of an application, but not all. For example, only the images used in a React application
Impact of changing cache headers on the origin server
Enabling logging
Manually forcing cache invalidation
Adding dynamic capability with Lambda@Edge
Adding security to CloudFront content, i.e. content that requires an authorised user
Using a LetsEncrypt cert

Next Steps

Next up (Episode 3) is AWS Certificate Manager, you can follow along with episode 3 on this Twitter thread: https://twitter.com/devskilldojo/status/1333094917732757506

Learn AWS with me :: Episode 1 : Introduction

Greg Fullard — Mon, 23 Nov 2020 05:27:14 +0000

I've recently became aware of a movement which aims to replace violent/inappropriate sayings with alternatives that serve the same purpose, but without the negative associations. Here's a great one I came across yesterday: Feeding 2 birds with one scone. This precisely describes what I'm trying to do on most days: In a word, I'm always looking for a twofer

And I found the perfect one today. Here the two goals I am currently pursuing:

I would love to build my own AWS skills, possibly even work through their entire certification hierarchy, And
I have a new business venture (DevSkillDojo.com) which requires careful curation of learning resources for technical skills

Instead of treating them as two independent goals, I realized, that if I "Learn in Public", then I'd be able to achieve both goals by expending a single amount of effort.

I can truly have my cake AND eat it.

Woohoo.

So I will be using the coming weeks (or months) to systematically explore the AWS ecosystem, one topic at a time.

Each topic will last exactly 1 week
During the week I will research the topic/service, publishing any lessons learnt on Twitter
I'll curate the best learning resources for that topic and share them on Twitter
I'll document the important learning concepts and prerequisite skills in the DevSkillDojo.com KnowledgeBase
At the end of the week, I'll write a summary article on the topic, linking to the various resources collected during the week.

The order of topics to be addressed will probably be a bit fluid, but I suspect we'll start of with:

CloudFront
S3
IAM
EC2
SQS
etc.

If you want to join along, follow @DevSkillDojo on Twitter. Of course, the weekly articles will be here on Dev

Learning Software Development is like building a jigsaw puzzle

Greg Fullard — Mon, 22 Jun 2020 18:27:18 +0000

I like building jigsaw puzzles.
Not as much as my wife does, to be sure, but I definitely enjoy it.

The thing is: I don't really understand why this is an enjoyable activity. You spend days or weeks patiently assembling a picture that you can quite easily see on the box, and when it's done, even though you might leave it on a table for a few days, you soon break it up and put it back in the original box. Is it just me, or is that weird?

The more I think about it though, learning Software Development is very similar to building jigsaw puzzles. And not just because it's weird - there are other reasons too.

At the beginning, the pile of pieces looks overwhelming and you have no clue where each piece fits. If you're new to software development, this is certainly true. Tech blogs discuss how technology X is no longer relevant, because technology Y covers those features but with reference confabulation. Yet you haven't even heard of technology X, let alone reference confabulation (FYI: Not a thing).

But don't despair, there's a plan.

It doesn't matter how big the puzzle is, you patiently begin sifting through the pieces to find the corners and the edges. These can be put in their place with minimal effort, and without even looking at any of the other pieces. In Software Development your corner pieces are HTML and CSS. Not JavaScript, that's different.

When I build puzzles, I spend a lot of time just looking at the picture on the box, examining its details. It forces me to look at a single picture more intently than you would ever look at any other photo or picture. This is one of the mysterious joys of building puzzles - it focuses the mind. I spend an equally large amount of time sifting through the hundreds of puzzle pieces - just looking at each one, wondering how it fits together. Trying to imagine where it fits into the big picture.

When learning software development, this is an equally important step. If you open a website, look at the details. Look at the overall layout. What colour scheme was used? What data entities and attributes are displayed? What data is personalised to the current logged-in user, and what data is generic? How are the menus structured, what modal pop-ups are used, etc.? Even though you might not understand how the whole site works, you should start thinking about how these things fit together.

The human brain is an amazing thing. If you pump it full of information and let it process on its own time, it'll figure out how things fit together.

When the corners are in place, and while you're sifting through the pieces, you will identify all the edge pieces. These are not as easy to slot into place as the corners, but they are easier than starting with the section of blue sky in the landscape. The edges give you a safe space to begin figuring out how different pieces fit together, without being totally overwhelmed.

In my opinion, the software development equivalent of this is learning fundamental skills like:

General programming concepts like variables, control structures, data structures, etc. You can learn these in any general purpose programming language like Python, JavaScript, Java, etc. Don't be too hung up on which one you choose - these skills are transferable to all programming languages.
Data Storage concepts, like relational databases, SQL, etc.
Analysis skills like user stories and understanding the problem domain with domain modelling (in UML).
Operating system basics like how the file system is structured, how to use command line tools and how to install software without using a sterilized "App Store".

Another thing about puzzles: You don't go all-out building the whole puzzle in one sitting. It takes days, sometimes weeks. Some days you just spend a few minutes, other days you spend many hours. But the puzzle is always in the back of your mind. And every time you walk past the dinner table it reminds you of an unfinished challenge.

Sometimes you have a lot of momentum, slotting in piece after piece. Other times it feels like you're endlessly scanning for a piece, but you can't find it. And there are always a few pieces that you come across again and again, but you can't seem to figure out where they fit.

As the assembled sections of the puzzle grows, things gradually become easier. This is because you have more context, and more experience of the overall picture, and the number of pieces in the pile gets smaller.

The same is absolutely true about learning Software Development. Initially everything is new, which means everything is either very difficult, or impossible, to understand. But it doesn't stay like this forever: the more things you understand, the more context you have. And the more context you have, the easier it becomes to learn new things.

It's the ultimate snowball effect.

The last aspect of puzzle building that we should highlight is that the joy is in the process, not the end result. That's why we can so easily break up a puzzle that we spent weeks building. The real satisfaction is the tactile feeling when one puzzle piece slots into another. It's like a mini brain-orgasm. That's why people buy huge puzzles - it includes many brain-orgasms.

Yes, there is also a sense of achievement when the puzzle is finished, but that feeling is not bigger than any of the hundreds of small victories that you experienced along the way.

Learning software development is like an endless puzzle. Your picture will never be complete, and new pieces are constantly being added to the pile. As a result, you will never be able to stand back and look at a fully built picture, knowing that you understand everything. But that's not the point.

The point is to love the learning journey. And I certainly do.

Article originally published at: https://devskilldojo.com/learning-software-development-is-like-building-a-puzzle/

Photo credits:

Bianca Ackermann (https://unsplash.com/@biancablah)