Forem: Lewis Gentle

Why I started an API service

Lewis Gentle — Mon, 25 Jul 2022 08:49:00 +0000

I recently launched an API for sending SMS – SMSjet.net. It has been one of the most fulfilling projects I've embarked on in a long time, and I wanted to share my story to hopefully inspire my fellow builders out there to build something you are proud of.

GTFOL

"Get the f*** off localhost" was a mantra that I'd read on Twitter, and it stuck with me. Too often as developers, we start building something out of curiosity or to teach ourselves something. We tinker, we add features, and we explore new ways of doing something, but we always do it at 127.0.0.1 / localhost. Our work is cut off from the world, and this separation more often than not leads to our side projects dying from a lack of oxygen.

In building SMSjet I wanted to do something other than building 80% of the service and keep it isolated on my machine. I wanted this new site to live and breathe. I wanted there to be something at stake – I wanted to get the f*** off localhost.
So I did. I bought a domain, I bought a cheap Linux VPS from Hetzner, I linked the two, and I began using VS Code's built-in SSH features to write my code directly on my production server. After a few setup commands and Django boilerplate – there it was, my new site, naked and exposed to the world in all its incompleteness.

After I got over the initial fear that someone would uncover the IP, load my incomplete site and laugh at how nothing worked – I felt free. After every change and incremental improvement, I had the choice of sending a friend the link and asking what they think of it. It felt real, and it was real.

Getting the f*** off localhost may expose your unfinished work to prying eyes, but nobody will likely find your site without your help. Just make sure you set up a somewhat secure server environment, and you can build out in the open.

Ok but why an SMS API?

I'm a big fan of Python and wanted to learn how the FastAPI library works. Previously I had created APIs through Django-REST API, but I never quite felt like I was "doing it right". One thing I love about FastAPI is how well documented it is. FastAPI's documentation is great. I honestly felt like a child would be able to build a REST interface if they read through the docs a couple of times.

It was on the backbone of my interest in exploring FastAPI that I built out some physical infrastructure to launch an SMS Gateway. The phrase "when you have a hammer, everything looks like a nail", should be rewritten for programmers:

When you have a new library, everything looks like a viable SaaS idea

What I love about FastAPI is how it is self-documenting. If you've written robust API code, your documentation will be robust. The Swagger Docs that FastAPI generates are also fully interactive, and allow you to enter real values and send requests straight from the documentation – check it out here.

If you're feeling bored with development, throw yourself into the deep end. Go and find a technology you know next to nothing about, and build a product with it. You'll find yourself invigorated and excited about programming because you're not programming, you're building.

Key Lessons

Shipping a product doesn't have to be scary, you can even do it on Day 0 of development if you're brave.
Give your projects the chance to succeed by GTFOL
Building something is the best way to learn something new
SMSjet is an awesome way to send SMS cheaply. Sign up here and get 100 free credits to use for your next project.

If you're a fellow builder and want help setting up SMS for your bootstrapped project, reach out here, I'd be more than happy to throw some more free credits your way. <3

Project: How To Build a Simple & Extendable Blogging Platform with Django & Python

Lewis Gentle — Sun, 02 Jan 2022 07:41:52 +0000

Preface

Recently I felt like I wanted to branch out and learn something new. I've always been interested in the practical and creative side of programming, so being able to deploy a project that is public facing was an exciting departure from the myriad of bespoke and educational Python scripts I've written.

Django was exciting to me for a few reasons:

Popular and Scalable (Instagram, Spotify, Dropbox)
Excellent Documentation
Embraces Test Based Development

I started my journey by cozying up with the official Django tutorial which teaches you how to write a simple poll app. This was a good intro, and opened my eyes to the simplicity and beauty of writing unit tests in Django. However, I wanted something a bit friendlier – something in-between a drawn out 4 hour monetised Youtube video, and the official documentation. This lead me to (DjangoGirls)[https://tutorial.djangogirls.org/en/], an excellent bottom-up intro to Django with a focus on promoting Women in STEM.

DjangoGirls might not appeal to those who claim to have been grinding out leetcode problems since kindergarten, but for me, the mid-paragraph smiley faces and congratulatory and plainspoken tone of the tutorials was perfect.

I won't try to rework the great tutorial DjangoGirls has already put together, but rather add some additional resources that I found interesting and useful when putting my blog together.

PythonAnywhere

PythonAnywhere.com makes deploying your Python projects on the web extremely simple (and free).

Virtual Environments (venv)

Using a virtual environment at the start of your journey is incredibly important, although it might not seem like it at first, but it's crucial for making sure your code not only works on your machine, but will work for others. See the DjangoGirls tutorial on starting a venv for your project.

GitHub Actions

Automating the testing of your projects is incredibly important, and gives you an inexplicable insight into how your application truly works. Writing tests with Django isn't covered in the DjangoGirls tutorial, so for this I highly recommend this article in the official Django documentation

Here's an example of a simple test I wrote for the DjangoBlog which can be run through python manage.py test:

class IndexPageTests(TestCase):

    def test_request_index_page(self):
        '''
        Make sure the homepage is reachable
        '''
        response = self.client.get('/')
        self.assertEqual(response.status_code, 200)


    def test_post_creation(self):
        '''
        Make sure the post creation is working
        '''
        create_post('Test title', 'Test text')
        self.assertTrue(Post.objects.filter(title='Test title').exists())

    def test_posts_are_visible(self):
        '''
        Make sure the posts are visible on the index page
        '''
        create_post('Test title', 'Test text')
        response = self.client.get('/')
        self.assertContains(response, 'Test title')

Once you've written your tests, you can actually get GitHub to run these tests on their servers through the magic of GitHub Actions – this means every new commit you make to your repo will get tested, and quickly let you know if you've broken anything before you get a chance break anything else.

This is where your virtual environment becomes really useful. You'll need to provide GitHub with a requirements.txt file which contains all of your projects dependencies. pip can quickly generate this for you by running $ pip freeze > requirements.txt from inside your virtual environment. For a better understanding of the beauty of a venv, this article is excellent.

With the requirements.txt in your root directory, go to your GitHub repo, click GitHub actions and select Django. This will create a .github/workflows/django.yml file which tells GitHub how to test your codebase. Due to some incompatibilities, I was unable to get my code to pass using python 3.7, so I limited the testing scope to versions 3.8 in the django.yml file:

---snip---
    strategy:
      max-parallel: 4
      matrix:
        python-version: [3.8, 3.9]
---snip---

Now that everything's setup, you can add a badge to your README.md which will show whether your tests are passing:

import sanity: Python Modules That Keep Me Sane 🐍

Lewis Gentle — Fri, 13 Aug 2021 02:23:16 +0000

One of the many great things about the snake language (read: Python) is that there's a huge number of modules and libraries that we can easily tap into to make building cool stuff a lot easier.

Python is unlike PHP, where a travelling function salesman will arrive every 2 minutes offering you a new built-in function (i.e. functions which are always accessible). Seriously, there are over 1000 built-in functions in PHP... whereas mere mortal Python 3 has a humble 68 built-in functions. Thus, becoming great at Python requires being able to effectively navigate the zoo of Python modules out there (and getting really fast at smashing pip install into your terminal. Unless of course you demand having absolute control over your entire codebase – in which case, maybe C++ is more your thing.

With all that said, I'm a complete noob at programming. I know next to nothing. But I thought it might help some other beginners (and myself in 2 days when I forget one of these modules) to compile a list of modules I've found to be really useful. A lot of these are either written by Al Sweigart or I learned about them in his excellent book [Automate The Boring Stuff] which you can read free online(https://automatetheboringstuff.com/). Let's begin:

`pyinputplus`

One of the most exciting things I first learnt to do in Python was to take input from the user. It was magical. Until I realised how easy it was for users (aka me) to obliterate decimate my script by entering the wrong data type. This is known as input validation or 'accelerated grey hair growth'. pyinputplus is a module which contains a bunch of really useful functions which ensure the user enters the data type you want, and how you want it. For example, you can make sure they enter a goddamn positive integer:
pyinputplus.inputNum('Enter a positive number: ', min=1)
Or get their favourite McDonald's breakfast item by prompting them with a list of lettered options:
choices = ['McMuffin', 'Hashbrown', 'Pancakes'] pyip.inputMenu(choices, lettered=True)
Please select one of the following:
A. McMuffin
B. Hashbrown
C. Pancakes
Now taking orders is literally as easy as A, B, or C.

`pprint`

Sometimes when you're testing your code you just want to print a list or a dictionary in a more human friendly way. That's where prettyprint (pprint) comes in. Simply give it a list and your dictionary will go from a mountain of text, to a nicely printed outline... of text.

`colorama`

While we're talking about making things pretty and human friendly, colorama is what you should use if you want your terminal output to be ✨colourful✨. Sure you could use the ASCII escape codes or whatever, but these often fail across multiple platforms, and sometimes its easier to just enter something like:
print("New largest chain " + Fore.GREEN + str(largestChain) + Style.RESET_ALL)

`pyperclip`

This module makes it easy to interact with and manipulate the users clipboard. Execute pyperclip.copy(x) and x will be copied to the users clipboard, and use x = paperclip.past() and you'll have the users clipboard saved to x.

Of course there are some more fundamental modules and libraries such as os, CSV, and pathlib, but I thought I'd focus more on the niche modules which do one thing well and incite sanity.

💬 If you want to share your favourite python modules in the comments I'd love to hear about them!

First AWS Certificate! 🎓☁️

Lewis Gentle — Sun, 08 Aug 2021 12:49:41 +0000

I know it's not an actual certification, but it feels like an important milestone on my cloud journey. So here it is, one of many to come, my first AWS certificate 🥳:

I learnt a lot about AWS and the power and efficiency of Lambda. Really excited to try it out soon. Time to get back to Automate the Boring Stuff, so I can take my favourite reptile programming language on this plane to the cloud 😎.