DEV Community: Casual Coders

Credit Card Skimmers & Open Source | Causal Coders Podcast

Chandler — Mon, 12 Feb 2024 13:46:47 +0000

Season 2 of the Casual Coders podcast is live! I was not in the first episode, but it’s still a good one! In this first episode they talk about credit card skimmers and how credit cards work, the best open source tools, and a long running web server project by one of our hosts! Available on Spotify, Apple Podcasts, YouTube, or wherever you get your podcasts!

Casual Coders Podcast • A podcast on Spotify for Creators

Welcome to the Casual Coders Podcast! We're a group of makers and engineers who talk nerd and make cool stuff! We strive to release two podcasts a month! Follow our socials! YouTube | https://www.youtube.com/c/CasualCodersOfficial Instagram | https://www.instagram.com/casualcodersprojects/ Twitter | https://twitter.com/CasualCoders Facebook | https://www.facebook.com/CasualCodersProjects TikTok | https://www.tiktok.com/@casualcoders

creators.spotify.com

Deploy your containerized app in 5 minutes with Fly Machines

Chandler — Thu, 23 Mar 2023 20:03:03 +0000

Fly Machines is Fly’s new runtime for FirecrackerVMs. Firecracker is a free and open source container runtime developed by AWS. Fly Machines, or AppsV2 as its also referred to, are more aimed at serverless functions but it can be used as a normal VM host with easy HTTP(S) routing.

While a normal Fly App has a configuration file, a Fly Machine doesn’t. A Fly machine is just one part of an app, which can have distributed Fly machines across different regions. Currently its on the dev to handle all of that. Any environment variables should either be put in the Docker container itself or passed at runtime (provided they are not secrets which are handled the same as they were before), as should the command to run the container. I should note that the fly m run command, which is the command used to start a container using a machine, does have a flag to specify a launch command ( —-comand, -c ), however at the time of writing it didn’t work.

Preparations

Throughout this section and the one below it, it is assumed you already have a Dockerized application. If not, I recommend reading up here before proceeding.

First, you have to create a new application on Fly.

fly apps create --machines --name your-name-here

After that you can add volumes and secrets to it like you normally would, passing in the --app, -a flag to specify the application in question.

fly secrets set MY_SECRET_HERE="password" -a your-name-here
fly volume create your-volume-here --region lax -a your-name-here -s 3 # in GB

Unlike a normal fly app, you have to manually allocate IP addresses. If your app is just running on an HTTP server, you can use the shared IPv4 address.

fly ips allocate-v4 --shared -a your-name-here

If you aren’t just hosting an HTTP server, you’ll have to either settle for IPv6 (which is free) or pay $2/mo for an IPv4 address.

fly ips allocate-v6 -a your-name-here
fly ips allocate-v4 -a your-name-here # costs $2/mo per IP

Deployment

When you run fly m run , it takes all the flags for ports, volumes, and environment variables, just the same as Docker. As mentioned earlier they have a command that is supposed to allow you to set the command at runtime, however it didn’t work for me. My solution was to just change the CMD line in my Dockerfile to the command I wanted.

Let’s assume you have an app with an HTTP server on 7500 and you want that to be accessible via your app’s Fly domain name. Since we made the region for the above volume lax (Los Angeles), we will assume the same for the deployment.

fly m run . -p 443:7500/tcp:tls:http -v your-volume-here:/data --region lax -a your-name-here

This will:

Build a Docker container using the Dockerfile in the current directory (the .)
Set up a port forward to external port 443 (which is the standard HTTPS port) and internal port 7500 (our hypothetical web server), specifying that we want this to use TLS and HTTP in the options.
Specify volume your-volume-here to be mounted to /data inside the container.
Deployed to lax
Deployed the new machine to the app your-name-here

Conclusion

In this tutorial, we have explored how to work with Fly Machines, or AppsV2, to create, configure, and deploy applications using FirecrackerVMs. We covered the steps required to create a new application, allocate IP addresses, manage secrets and volumes, and deploy the app to a specific region.

By following this guide, you should now be equipped with the knowledge to build and deploy serverless applications or even utilize Fly Machines as a normal VM host with easy HTTP(S) routing. As a developer, it is essential to adapt to new and emerging technologies that can improve the efficiency and performance of your applications, and Fly Machines is one such tool that can help you achieve that.

Now it's your turn to start building your applications with Fly Machines and harness the power of FirecrackerVMs to enhance your serverless workflows. Good luck, and happy coding!

My Favorite Free Hosting Services of 2023

Chandler — Thu, 16 Mar 2023 15:23:01 +0000

Are you a developer who's just starting out and looking to launch your first website or application? Or maybe you're just looking for ways to save on hosting costs? Either way, you're in luck because in this blog post, I'll be sharing my favorite free hosting services of 2023.

While many programming tools and resources are available for free, hosting services often come with a price tag. However, with the rise of cloud computing and advancements in web technology, there are now a number of hosting providers that offer free plans with generous resource allocations and features!

In this post, I'll be reviewing some of the top free hosting services available for developers in 2023. I'll cover their features, limitations, and user experience to help you make an informed decision on which provider to choose for your next project.

Frontend

Vercel

Vercel is a cloud platform for building, deploying, and scaling web applications. It provides an all-in-one platform for developers to build, host, and deploy their applications in the cloud.

Vercel's platform offers a number of features that make it popular among developers. One of its key features is its support for serverless functions, which allow developers to run server-side code without having to manage server infrastructure. This code can be written in Javascript/Typescript, Python, Go, and a few other languages. Vercel also provides support for static sites, React, Vite, Vue, Hugo and plain old HTML sites, as well as Next.js, a popular React framework that Vercel develops in-house, and is quickly becoming the most popular method for getting a React app off the ground.

In addition to its hosting platform, Vercel also offers a number of developer tools and integrations, including Git-based workflows, continuous deployment, and collaborative editing, making it super easy to get started!

Vercel is free for hobbyists, meaning if you’re deploying from your personal GitHub account, its free, with teams starting at $20/per developer.

Cloudflare Pages

You may know Cloudflare from their very fast and very secure DNS provider, or their CDN, or their DDoS protection, but did you know that you can have them host your website using their global CDN?

Cloudflare Pages is a cloud-based platform for building and deploying websites and web applications. It is designed to make it easy for developers to build, test, and deploy their applications with a simple, intuitive interface and seamless integration with other Cloudflare services.

With Cloudflare Pages, developers can build and deploy static sites and single-page applications (SPAs) quickly and easily. The platform provides a Git-based workflow for building and deploying applications, and it supports a wide range of front-end frameworks and libraries, including React, Vue.js, Angular, and more.

Cloudflare Pages also offers fast build times, thanks to its distributed network of servers and caching infrastructure. This helps to reduce the time it takes to build and deploy applications, making it easier for developers to get their applications up and running quickly.

In addition to its core features, Cloudflare Pages also provides a range of integrations and tools to help developers optimize their applications for performance, security, and scalability. These include access to Cloudflare's CDN, DDoS protection, and edge caching, as well as real-time analytics and monitoring.

Just like Vercel, you can even set up automatic deployment from GitHub, along with other CI/CD.

Unliked Vercel, Cloudflare Pages is free for as many developers you want with as many users as you want with unlimited bandwidth. They even have their own serverless compute called Cloudflare Workers (which I’ll get to later) where you can host backend code on! Once you need more advanced features past just hosting the website, or if you run Cloudflare Workers more than 100k times in a month, then you will have to pay.

Backend

Fly.io

Heroku free tier is dead. Fly.io is here to pick up the pieces.

Fly.io is a public cloud platform that is built on top of bare-metal servers in data centers around the world. The platform is designed to make it easy for developers to deploy distributed and real-time apps close to their users, no matter where they are. The goal of Fly.io is to deliver applications with the highest possible availability and the lowest possible latency, all while providing a great developer experience.

One of the key features of Fly.io is its ability to allow developers to run their full stack close to their users. This means that developers can deploy simple web services or complex applications with multiple supporting services, all with ease. Fly.io offers persistent storage volumes and a ready-to-run Postgres database, as well as a fast internal WireGuard network for private communication between applications.

Fly.io also offers a unique approach to containerization. Instead of using Docker, Fly.io upgrades containers to full-fledged Firecracker microVMs. Developers can use a Dockerfile and remote builders to build an image with their app and its environment, or they can point to a pre-built Docker image. However, in many cases, developers won't even have to touch Docker. The platform's fly launch feature can scan source code and configure a project for deployment on Fly.io, and the builders will build the app's Docker image automatically when it's deployed.

Since your app is basically just a normal Docker container, if you ever decide you want to move it to another paid service, like AWS Elastic Container Service, or just run it in Docker on a server somewhere, you can!

Their free tier allows for up to 3 VMs total with 256MB of RAM each, 3GB of storage, and 160GB of bandwidth. That may not sound like a lot, but if all you’re working on is a hobby project, or you’re just getting started, that’s more than enough for most things. They also recently launch a free 100MB Redis Key-Value database that you can run with your app as well, which is a really nice way to cache information in your app.

Deta Space

This one is a bit strange. Deta was originally more along the lines of a Heroku competitor with a bit more restrictions. Now they’re kind of an odd hybrid platform-as-a-service that’s also a startup incubator.

The TLDR of how they work is that you create an app using their workflow using standard web technologies (NextJS, React, Vue, etc) as well as a backend (Python, Go, Rust, etc) and other people install the app to their own “personal cloud”. This has the advantage of meaning you can write your app as if you were the only user, but means that scaling it in the future may be difficult.

If you can get over their unusual workflow, your app is hosted for completely free. But only to other users of Deta Space for now. Their website makes it sound like in the future there is going to be a way for you to deploy your app with them somehow hosting it for you as well as collecting revenue for you but since they’re in Beta that could change.

Cloudflare Workers

Cloudflare Workers might be a bit tricky to work with, considering their runtime and API restrictions, but let me tell you, the perks they bring to the table make them absolutely worth the effort. Cloudflare Workers provide an impressive free tier of 100k runs, giving you the chance to explore and tweak your deployment without spending a dime.

Now, what makes these Workers so irresistible? They've got automatic scaling and a high-performance global network that makes your life as a developer a whole lot easier. No more fussing around with auto-scaling, load balancers, or paying for idle capacity! Plus, they support multiple languages like JS, Rust, C, and C++, with a bunch of templates and tutorials to get you going in no time.

Cloudflare Workers are super budget-friendly, offering the first 100, 000 requests per day free of charge and paid plans starting at a mere $5 for 10 million requests. With no servers to worry about and built-in edge storage through Workers KV, you can concentrate on crafting and innovating, leaving infrastructure headaches behind. They even let you generate assets like images, SVGs, and PDFs on the fly, delivering them to users as fast as static assets.

So, even though Cloudflare Workers come with a learning curve due to their runtime and API limitations, the benefits they offer in terms of distribution, speed, and affordability make them a fantastic choice for developers eager to harness the power of serverless architecture.

Database

Supabase

I’ll be upfront with you: I absolutely love Supabase.

Supabase is an open-source alternative to Firebase, which is a cloud-based mobile and web application development platform. It provides a suite of tools and services for building scalable, real-time applications with ease. Supabase is built on top of PostgreSQL, an open-source relational database, and provides a range of tools and services for working with data, authentication, and real-time events.

Here is something I’m going to say that will make every web developer ever swoon: they write the backend code for you.

Yeah, you read that right. Using their libraries, you can run a database on their cloud, have your users authenticate, and make authenticated requests to your database, without writing a single line of backend API code.

Supabase handles this by offering a feature called Row Level Security, where you can set security measures so your users have to pass a check before they can even see if a row exists, or before they can add or modify existing rows. This means that while you don’t write any backend code, its not any less secure than any other full stack application!

They also offer other services, such as an S3-compatible database-linked file storage service, as well as Deno-based serverless hosting!

You can have up to 2 databases with 500MB of storage and 512MB of RAM each. You also get 1GB of of file storage, and 500k function runs (which is more than Cloudflare!). This doesn’t sound like a lot, but with all the features and the the ease of development I consider their paid tier of $25/mo per database well worth it.

MongoDB

MongoDB is a popular open-source document-oriented database management system (DBMS) that uses a flexible, schema-free data model to store data in a JSON-like format. It was first released in 2009 by MongoDB Inc. and is designed to handle large volumes of structured, semi-structured, and unstructured data.

MongoDB is easy to interface with, especially in higher level languages like Python, Typescript, Java, among others. When I don’t need structured data, Mongo is my go-to database.

MongoDB offers a cloud-based database hosting service called MongoDB Atlas that provides free and paid plans for developers and organizations. The free plan is called the "M0 Sandbox" and provides users with a fully-managed MongoDB cluster with 512 MB of storage and shared RAM. The M0 Sandbox plan also includes access to MongoDB's community support and allows users to deploy up to three clusters for free.

Google Sheets

You can make an entire application using Google Sheets as a database. Would this work well if you’re trying to build the next Twitter? Of course not! But if all you’re trying to do is store data in a single table in a SQLite database for a hobby project, this may be worth the effort. Fireship did an entire video on the subject and he explains it much better job explaining why and how you would do this, so maybe go watch that if this seems interesting to you.

File Storage

Cloudflare R2

Cloudflare used their knowledge of affordable, distributed computing and put it to use creating R2. R2 is significantly cheaper than nearly all the competition, and its distributed, meaning your data is close to your users. The S3-compatible API lets you build versatile multi-cloud systems tailored to your needs, and you can move data around without any pesky egress fees. Plus, you'll get a cool 10GB for free! So if you're planning your next project, give Cloudflare R2 a spin and see how it can help you build an efficient, scalable, and affordable solution!

Backblaze B2

You may have heard of Blackblaze’s backup service for Mac and PC. Their service offers unlimited backup of your computer’s file storage for $6 per month. Well they have taken their knowledge from storing petabytes of people’s personal information and made a quite affordable option in the Object Storage space with their B2 service. Its 100% S3 compatible, and you get 10GB for free!

Conclusion

Whether you're looking for a frontend or backend solution, a database, or file storage, there's something here for everyone. While free plans may come with limitations, they're a great way to get started on your first project or experiment with new technologies without breaking the bank. So why not give one (or more) of these services a try and see what you can build!

How I Use Just to Quickly Organize Project-Level Commands

Chandler — Thu, 26 Jan 2023 20:34:44 +0000

Have you ever had a folder full of random scripts you used for automation? Have you ever tried to use a Makefile to script things? Or even put a bunch of run options in your package.json file? If so, you may have found that these tools lack the simplicity and ease-of-use that you need to automate your tasks effectively. That's where Just comes in.

A passive-aggressive way to run things.

Just is a command-line tool that provides a simple and easy way to run scripts and commands. It is similar to make in that it allows you to specify dependencies between commands, but it is more focused on running scripts and commands, rather than building and compiling software.

Just also provides some additional features such as parallel execution, caching, and error handling. It is designed to be easy to use and requires minimal setup, making it a useful tool for automating repetitive tasks.

Installation

If you have homebrew, its quite simple:

$ brew install just

If you have rust installed its also quite easy:

$ cargo install just

Its also available on various other *nix and Windows package managers, and as a Unix binary.

Examples

Here's an example of a simple justfile that demonstrates how to use Just to automate a few tasks (called recipes in their docs):

# Justfile

# This command runs the "clean" task before running the "build" task
build: clean
    echo "Building project..."
    # commands to build the project go here

# This command runs the "clean" task before running the "test" task
test: clean
    echo "Running tests..."
    # commands to run tests go here

clean:
    echo "Cleaning project..."
    # commands to clean the project go here

# This command can be run independently
deploy:
    echo "Deploying project..."
    # commands to deploy the project go here

You can execute the tasks defined in the justfile by running the command just <taskname>. For example, to run the build task, you would run just build. Just will automatically run any tasks that the task you're running depends on, in the order they're defined in the file.

In this example, you can see that the task build and test depends on the task clean, so if you run just build or just test, Just will run clean before running the task you requested.

You can also run the task deploy independently and it doesn't have any dependencies.

You can also add comments in your justfile using the # character, as shown in this example.

This is a simple example, but you can use Just to automate much more complex tasks and scripts.

Here is an example of a script I wrote for one of my projects:

# builds the docker image
build-docker:
    #!/bin/bash
    set -euo pipefail
    ARCH=$(uname -m)
    if [ $ARCH = "aarch64" ]; then
      ARCH="arm64"
    fi
    if [ $ARCH = "x86_64" ]; then
      ARCH="amd64"
    fi
    docker build -f docker/Dockerfile.$ARCH -t ceres .

# runs the executable in docker
run-docker mode="stout": check
    docker run --rm -p 8080:8080 -v $(pwd)/config:/app/config ceres --mode {{mode}}

# starts the daemon. Specify mode=prod to run in production mode (without grafana)
up mode="dev": build-docker check
    docker compose -f docker/docker-compose-{{mode}}.yml up -d

# shows daemon logs
logs mode="dev":
    docker compose -f docker/docker-compose-{{mode}}.yml logs -f

# stops the daemon
down mode="dev":
    docker compose -f docker/docker-compose-{{mode}}.yml down

With just you can add parameters to the scripts that you define, along with defaults. You can also specify an interpreter for your scripts. Bash and Zsh common ones, but I’ve even seen Python scripts written in a Justfile!

Good Practices

One piece of good practice is to define the default behavior, which is what happens when you run just without any additional commands. Here is what I usually write:

default:
    just --list --unsorted

When I run this in a project that has other scripts defined with comments, this is the output.

$ just
Available recipes:
    build                        # builds the executable
    build-docker                 # builds the docker image
    clean                        # cleans the build artifacts
    compile                      # alias for build
    default                      # default task
    down mode="dev"              # stops the daemon
    dump                         # runs the executable in dump mode
    fmt                          # Formats the project
    format                       # Alias for fmt
    logs mode="dev"              # shows daemon logs
    run *json                    # runs the executable in stout mode
    run-docker mode="stout"      # runs the executable in docker
    serve                        # runs the executable in serve mode
    up mode="dev"                # starts the daemon. Specify mode=prod to run in production mode (without grafana)

Hidden Tasks

You can also hide tasks from the list output with either a leading underscore or the [private] tag. Here is an example of both:

[private]
check:
    #!/bin/bash
    set -euo pipefail
    if [ ! -f config/optional.json ]; then
      echo "Optional 'optional.json' file is missing."
    fi
    if [ ! -f config/required.json ]; then
      echo "Please add a 'required.json` file."
      exit 1
    fi

_helper:
    echo "This is a hidden task"

Notice how in the above output, these are missing? They’re in my project’s Justfile, but they’re hidden as they are utility tasks I don’t want other devs to run.

Silent Tasks

If you don’t want a task to echo the commands, you can add an @ symbol before the command.

@quiet: # from the Just manual
  echo hello
  echo goodbye
  @# all done!

The @ symbol can also be used to invert the echo. For example, you can use @ to not echo certain commands in a normal task:

loud:
    echo "Hello"
    @echo "This is a test"

Conclusion

I hope you found this blog post helpful! I found that after I was introduced to Justfiles I use them for all my scripts in my projects! How do you normally keep track of your scripts and repetitive tasks in your projects? Will you use Just from now on? Leave a comment down below telling me about it! Happy coding!

My favorite Python packages!

Chandler — Wed, 14 Dec 2022 18:39:40 +0000

Python has a rich ecosystem of packages and tools. Because of its versatility, all manner of helper packages, command line tools, and rich libraries have been built. I have been coding in Python since 2012, and I’ve seen the ecosystem grow considerably. From dependency management, database ORMs, and server solutions, here are my favorite Python packages of 2022!

Arrow

Because `datetime` has always sucked.

Arrow is a package that makes working with dates in Python as easy as a single line of code - and not a complicated one either. Say you have a date string from your web app, 2013-05-11T21:23:58.970460+07:00. This can be converted with a single line of code using arrow, with no complicated formatting:

import arrow

date_one_str = '2013-05-11T21:23:58.970460+07:00'
date_one = arrow.get(date_one_str)

Need it as a datetime?

date_one_dt = date_one.datetime

Need the time right now?

now = arrow.now()

Need to convert from a datetime to an arrow time object?

arrow_obj = arrow.get(datetime_obj)

Need to get time from a string with formatting?

arrow_obj_two = arrow.get('2013-05-05 12:30:45', 'YYYY-MM-DD HH:mm:ss')

Need to format your arrow object?

date_one.format('YYYY-MM-DD HH:mm:ss ZZ')
# or even just
date_one.format() # if you just want a pretty string.

Need human readable strings?

date_one.humanize()

Need to shift time?

date_two = date_one.shift(hours=2, minutes=3)
# negatives are also acceptable
date_three = date_one.shift(years=-1)
# timezones are also a thing
date_four = date_one.to('US/Pacific')

Need to get from epoch?

# arrow assumes seconds for numbers
date_five = arrow.get(1661268857)
# floats work too
date_six = arrow.get(166126884.9243)

Now Tom Scott can be less angry about timezones. Or you can just use UTC like a normal dev.

OpenCV

What if your programs need to see?

Now this library is so big and versatile that I’m not giving you examples, but I will link you to some cool projects that use it. OpenCV is a computer vision library that was originally built for C but has wrappers for all manner of languages, with the most popular being Python. This allows you to take in video or image input from either a file, a webcam, or even a live video stream over the internet. You can then process each image using various techniques to get information from those images. Information can be as simple as an average color, or as complex as finding specific targets within the image.

This is not a small library, needing potentially gigabytes libraries depending on your OS configuration. It is also not the fastest when you are running big calculations, and will need heavy optimizations to keep framerates high if processing video.

If you need some tutorials, Awesome OpenCV has a massive list of books and online tutorials - both free and paid - to help you get started.

FastAPI

When you just need an API that’s fast.

If you have ever worked with micro frameworks like Flask or Sinatra, you will feel right at home with FastAPI. Built to be as fast as possible, FastAPI allows you to make all manner of Python web applications - from simple APIs to massive full stack web applications. Using Python Dataclasses as well as type hinting, it can make your API as close to idiot proof as possible. It even has support for OpenAPI, as well as auto generated documentation. Here an example of a super minimal FastAPI application.

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"message": "Hello World"}

That’s it! Python dictionaries are automatically converted to valid JSON objects when returned.

SQLModel

Now you can make APIs, how about some data to serve?

SQLModel is a library for interacting with SQL databases from Python code, using Python objects. It is designed to be intuitive, easy-to-use, highly compatible, and robust. It is powered by Pydantic and SQLAlchemy and relies on Python type annotations for maximum simplicity. The key features are: it's intuitive to write and use, highly compatible, extensible, and minimizes code duplication. The library does a lot of the work under the hood to make writing code easier and eliminate the need to duplicate models in SQLAlchemy and Pydantic.

Its compatibility with Pydantic means that any models you write for SQLModel also natively work with FastAPI! Here are some snippets from the official docs.

from typing import Optional

from sqlmodel import Field, SQLModel

class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str
    secret_name: str
    age: Optional[int] = None

And here is an example of using FastAPI with SQLModel.

from typing import Optional

from fastapi import FastAPI
from sqlmodel import Field, Session, SQLModel, create_engine, select

class Hero(SQLModel, table=True):
    id: Optional[int] = Field(default=None, primary_key=True)
    name: str = Field(index=True)
    secret_name: str
    age: Optional[int] = Field(default=None, index=True)

sqlite_file_name = "database.db"
sqlite_url = f"sqlite:///{sqlite_file_name}"

connect_args = {"check_same_thread": False}
engine = create_engine(sqlite_url, echo=True, connect_args=connect_args)

def create_db_and_tables():
    SQLModel.metadata.create_all(engine)

app = FastAPI()

@app.on_event("startup")
def on_startup():
    create_db_and_tables()

@app.post("/heroes/")
def create_hero(hero: Hero):
    with Session(engine) as session:
        session.add(hero)
        session.commit()
        session.refresh(hero)
        return hero

@app.get("/heroes/")
def read_heroes():
    with Session(engine) as session:
        heroes = session.exec(select(Hero)).all()
        return heroes

They’re a perfect pairing for any sort of CRUD application written in Python!

Conclusion

Do you have any Python packages you use daily? Let me know in the comments! Thanks for reading!

How to use Object Oriented Programming in Go

Chandler — Tue, 13 Dec 2022 22:36:49 +0000

Go is not an Object Oriented Programming language. It is definitely aimed more at the functional crowd, as its support for OOP is lacking at best, preferring C-style structs that can have methods attached to the more traditional style of OOP that Java, Javascript, Python, and C++ support.

How would I get started?

To create a class in Go, you can use the type keyword, followed by the name of the class, and then the struct that represents the data for the class. Here is an example of a simple class called Person that has two fields, name and age:

type Person struct {
  Name string
  Age int
}

You can then create an instance of this class by using the new keyword, like this:

p := new(Person)

To set the values of the fields in the class, you can use the dot notation, like this:

p.Name = "John"
p.Age = 20

You can also create a class with methods, which are functions that are associated with a specific class. Here is an example of a Person class with a greet method:

type Person struct {
  name string
  age int
}

func (p *Person) Greet() string {
  return "Hello, my name is " + p.Name
}

You can call the greet method on an instance of the Person class like this:

p := new(Person)
p.Name = "John"
p.Age = 20

fmt.Println(p.Greet())  // Output: "Hello, my name is John"

Just like when writing other types of functions in Go, capital letters signify public functions that can be called externally. The same goes for the attributes of the struct.

Constructor? I barely know her!

There is no concept of a constructor method in Go.

I like defining defaults as much as the next OOP programmer, and the easiest (and only) way to do it in Go is using a factory method that returns a new instance of said "class" (struct).

type Person struct {
  Name string
  Age int
}

func NewPerson(name string, age int) *Person {
  p := new(Person)
  p.Name = name
  p.Age = age
  return p
}

What about my inheritance?

In Go, class inheritance works by allowing type embedding. Type embedding allows you to use one type as a part of another type. This is similar to class inheritance in other languages, but instead of subclassing one type from another, a type is embedded inside another type. This allows the embedded type to inherit the properties and methods of the containing type. Type embedding is a powerful technique that can be used to create complex types with a lot of functionality.

Let's say we have a type "Vehicle" and a type "Car" which embeds Vehicle. Car will inherit all the properties and methods of Vehicle, as well as any additional ones it may have. So, for example, if Vehicle has a "Drive()" method, Car will also have this method. This allows us to reuse code and create complex types.

package main

import "fmt"

type Vehicle struct {
    Wheels int
}

func (v *Vehicle) Drive() {
    fmt.Println("Driving")
}

type Car struct {
    Vehicle
    Doors int
}

func main() {
    c := Car{}
    c.Drive()
}

You can override the Drive() function by making a new one but instead of passing in a pointer to a vehicle, you do a pointer to a Car.

func (c *Car) Drive() {
    fmt.Println("Driving on a road")
}

This is not the same for attributes (in this case Doors for the Car and Wheels for both). If we want to set the number of wheels on the Car, we will need to create an instance of Vehicle in the Car. Here is an example factory function that does just that.


func NewCar(doors int) *Car {
    c := Car{
       Vehicle{Wheels: 4},
       Doors: doors,
    }
    return &c
}

// and if we want to access the Wheels on the Car
mustang := NewCar(4)
fmt.Println("A car has ", mustang.Vehicle.Wheels)

One more thing of note, pointers allow more control with the structs than using by value, so always try to use a pointer when working with classes in Golang.

I hope this tutorial helped. Question? Comments? Concerns? Leave them below!

How To Create and Push a New Git Repo to GitHub

Chandler — Thu, 08 Dec 2022 13:00:00 +0000

To create a new Git repository locally and commit all files, you will need to have Git installed on your computer. If you don't have Git installed, you can download it from the official website.

Once you have Git installed, follow these steps to create a new repository and commit all files:

Open a terminal or command prompt and navigate to the directory where you want to create the Git repository.

Run the following command to initialize the repository:

$ git init

This will create a new .git directory in the current directory, which will be used to store all the version control information for your project.

If you don't have any files to commit, make an example file called README.md and add The title of your project preceded by a hashtag (or pound symbol if you prefer the classical term) along with a short description of your project a few lines below. For example:

# This is a markdown title

This is a markdown paragraph.

Once you have some files, you can add them to the repo.

Add all the files you want to include in the repository by running the following command:

$ git add .

This will add all the files in the current directory and its subdirectories to the repository. You can also specify individual files to be added by replacing the . with the file names, separated by spaces.

Once all the files are added, you can commit them to the repository by running the following command:

$ git commit -m "Initial commit"

This will create the first commit in the repository, which will include all the files that were added in the previous step. The -m flag is used to specify a commit message, which should briefly describe the changes that were made in this commit.

To create a new empty Git repository on Github, follow these steps:

Log in to your Github account and go to the Github homepage.
Click on the plus icon in the top right corner of the page, and select "New repository" from the dropdown menu.

On the next page, enter a name for your repository in the "Repository name" field. This should be a short and descriptive name that accurately reflects the contents of the repository.
In the "Description" field, you can enter a longer description of the repository if you want. This is optional, but it can be helpful to provide more information about the purpose of the repository.
You can set the visibility to whatever you prefer. If you want others to be able to see your work, set it to "Public". Otherwise, set it to "Private".

Leave the "Initialize this repository with a README" option unchecked, as we want to create an empty repository.
Click on the "Create repository" button to create the repository.

Your new empty repository will be created and you will be taken to the repository page. From there you can copy the project URL (usually ending in .git) and push your local changes to it.

Run the following command to add the remote, replacing <github_project_url> with the URL of the Github project you copied:

$ git remote add origin <github_project_url>

This will add the remote to your local repository. You can verify that the remote was added successfully by running the following command:

$ git remote -v

This will list all the configured remotes for the repository, along with their URLs. The remote you added should be included in the list.

Once the remote is added, you can push your local commits to it by running the following command:

$ git push origin main

Git should prompt you to log in. Enter your GitHub username and password in the prompt window.

This will push all the local commits on the main branch to the remote repository.

If you add any additional files, you will need to run git add . again. After you make any additional changes, simply repeat the steps of git commit and git push, but be sure to change the message (the part within the quotations) to reflect what you did. Messages should be short and concise, with a general rule of thumb to be to keep them less than 50 characters. For example, "Add new function x" would be acceptable.

Was this helpful? Let us know in the comments below!

Scary AI, Linux, and Simping For Elon | Casual Coders Podcast

Chandler — Wed, 07 Dec 2022 16:38:16 +0000

This week on the Casual Coders Podcast, we discuss ChatGPT, Linux, Twitter, and Neuralink!

Follow Casual Coders:

Twitter | https://twitter.com/CasualCoders

Facebook| https://www.facebook.com/CasualCodersProjects

TikTok | https://www.tiktok.com/@casualcoders

Twitch | https://www.twitch.tv/casualcoders

Insta | https://www.instagram.com/casualcodersprojects/

YouTube | https://www.youtube.com/channel/UCmkQBj1JyI0x53fn81L-EbA

Supporting USB C to C Charging and Data Transfer

Ian — Mon, 05 Dec 2022 22:31:09 +0000

Have you ever had a device that has a USB Type C port on it, but it doesn't seem to charge using USB C to C cables? This seems to be a common problem to us. Just the other day, we were filming and attempting to recharge one of our microphones, and we were unable to use the USB type C Power Delivery brick that was sitting right in front of us. This is truly infuriating, especially once you know the answer. Today, we're going to dive into the USB Type C Legacy Device specification.

The Physical Connectors

The most barebones physical USB C connection, USB 2.0, has twelve pins. MicroUSB has five.
This could be a point of confusion for new or inexperienced designers using USB Type C for the first time. One may simply assume that you can connect the pins straight through, as you would for MicroUSB, and that it will work just fine. And, if they haven't tested thoroughly, they may find this to be the case. To support USB A to C, you need only connect Voltage, Ground, and USB Data. However, upon connecting a USB C to C cable, you'll find exactly zero volts at the output. This is because the USB C controller has no idea that anything was just plugged in at all, so it won't provide power, even if the device has it's USB Data lines connected.

The CC Lines

This is where the CC lines come in. The UCB C controller uses the CC lines to establish the protocol with which to communicate with the connected device. For our purposes, this will be a power delivery request for 5v, 9v, 12v, or 20v [with 48v soon to come]. This requires an extra integrated circuit, or microcontroller to establish this communication though. For legacy devices where a simple 5v is needed however, you can simply stick two 5.1k Ohm pull-down resistors on the CC lines. Each line needs it's own resistor, as the specification uses these lines to determine the 'direction' the plug was inserted. This tells the controller that it's communicating to a legacy device and that it needs to provide 5v up to 1.5A or 3A depending on the source's capabilities.

The Bottom Line

And of course, what does this cost? Literally nothing. For a mere 100 5.1k Ohm resistors, we pay the unit price of $0.0004. That's $0.04 for the entire order. Each device needs two of these resistors, so we've spent less than a single cent to support the proper USB C legacy specification. This allows both USB A to C cables, and USB C to C cables to charge our connected device. If there's one thing you take away from this, PLEASE include those two tiny resistors in any of your designs that use USB C for charging. And Please, Let's get rid of MicroUSB entirely. We want one cable to rule them all.

How to Create and Edit GitHub Issues & PRs

Chandler — Mon, 05 Dec 2022 22:17:56 +0000

GitHub is a powerful platform for collaborating on code, and it is essential to understand how to create and edit pull requests and issues in order to take full advantage of its features.

Creating and editing issues and pull requests on GitHub is an essential part of the development process. Issues and pull requests allow developers to collaborate and communicate with one another, as well as to track and plan tasks.

Issues

A GitHub issue is a feature of GitHub that allows users to create and track tasks or problems related to a repository. Issues can be used to track feature requests, bug reports, and other project-related topics. They are also a great way to discuss ideas, find solutions, and collaborate with other users. Issues can be assigned to team members, labeled, and sorted into different categories. Using GitHub issues is an effective way to keep track of the progress of a project and ensure that all tasks are completed on time.

To create an issue on GitHub, simply navigate to the repository where you wish to create the issue and click the “Issues” tab.

Then, click the green “New Issue” button and fill out the form with a descriptive title and detailed description. Once you have completed the form, click the “Submit new issue” button.

To edit an existing issue, click on the issue you wish to edit and then click the “Edit” button in the upper right corner of the page. Make any desired changes, then click the “Submit” button.

Pull Requests

A GitHub pull request (commonly referred to as simply a “PR”) is a way for developers to collaborate on a project. It allows a developer to submit changes to a project which can then be reviewed and approved by other developers. This is useful for ensuring that only quality code is merged into the main project, and for keeping track of changes and progress. Pull requests also make it easier for developers to track their own contributions to a project. By using pull requests, developers can quickly and easily collaborate on a project in a secure and organized manner.

Creating and editing pull requests is similar to creating and editing issues. To create a pull request, navigate to the repository where you wish to create the pull request and click the “Pull Requests” tab. Then, click the green “New pull request” button and fill out the form. Once you have completed the form, click the “Create pull request” button.

Editing a pull request is much like editing an Issue. To edit an existing pull request, click on the pull request you wish to edit and then click the “Edit” button in the upper right corner of the page. Make any desired changes, then click the “Update comment” button.

With the help of issues and pull requests, developers are able to collaborate and communicate effectively. Creating and editing these items is a simple process, and can help streamline the development process.

How to Clone, Commit, and Push to a Git Repo

Chandler — Fri, 02 Dec 2022 21:29:17 +0000

Cloning a git repo is one of the first steps to getting started with a new project or working on an existing project. It allows you to download a copy of an existing repository from a remote server and start making modifications. In this article, we'll go over how to clone a git repo, create a new branch, commit to the new branch, and then push the branch to the remote server. For this example we will use GitHub as the remote server.

Cloning the Repo

To begin, open your terminal and navigate to the directory where you want to clone the git repo. Then, run the following command, replacing “[repo name]” with the name of the repository you want to clone. An example of a repo name is chand1012/blog .

git clone https://github.com/[repo name].git

This will download the entire repository to your local machine.

Creating a New Branch

Next, you'll want to create a new branch to work on. A branch can be thought of as a slightly different version of the source code that has the same starting history. The ultimate goal is to eventually merge the new branch back into the primary branch, usually called “main” or “master”. To do this, run the following command from within the repository's directory:

git checkout -b [branch name]

Replace “[branch name]” with the name you'd like to give your new branch.

Adding & Committing Files

Now, you can start making changes to the repository and committing them to the new branch. To do this, first make your changes, then run the following command:

git add -A

Once the files have been added, you can commit the changes with the following command:

git commit -m "[message]"

Replace “[message]” with a brief description of your changes.

Pushing the Branch

Finally, you can push the new branch to the remote server with the following command:

git push -u origin [branch name]

Replace “[branch name]” with the name of your new branch.

And that's it! You've successfully cloned a git repo, created a new branch, committed to the new branch, and pushed the branch to the remote server.

DEV Community: Casual Coders

Credit Card Skimmers & Open Source | Causal Coders Podcast

Deploy your containerized app in 5 minutes with Fly Machines

Preparations

Deployment

Conclusion

My Favorite Free Hosting Services of 2023

Frontend

Backend

Database

Google Sheets

File Storage

Conclusion

How I Use Just to Quickly Organize Project-Level Commands

A passive-aggressive way to run things.

Installation

Examples

Good Practices

Hidden Tasks

Silent Tasks

Conclusion

My favorite Python packages!

Arrow

Because datetime has always sucked.

OpenCV

What if your programs need to see?

FastAPI

When you just need an API that’s fast.

SQLModel

Now you can make APIs, how about some data to serve?

Conclusion

How to use Object Oriented Programming in Go

How would I get started?

Constructor? I barely know her!

What about my inheritance?

How To Create and Push a New Git Repo to GitHub

Scary AI, Linux, and Simping For Elon | Casual Coders Podcast

Supporting USB C to C Charging and Data Transfer

The Physical Connectors

The CC Lines

The Bottom Line

How to Create and Edit GitHub Issues & PRs

Issues

Pull Requests

How to Clone, Commit, and Push to a Git Repo

Cloning the Repo

Creating a New Branch

Adding & Committing Files

Pushing the Branch

Because `datetime` has always sucked.