DEV Community: Jordan Tingling

The First AI-Powered URL Shortener - Shrinkify

Jordan Tingling — Sun, 26 Oct 2025 22:11:15 +0000

What does he mean by AI-powered URL Shortener?

Hey Guys, I'm Launching Shrinkify today and figured this community i've been apart of for a longtime would appreciate the honest behind-the-scenes.

I had an issue with how things were

I was paying $29/mo to Bitly. For what? A database entry and a 301 redirect. Maybe some basic charts if I was lucky.

The idea wondered in my head for a while, that shortening urls don't need to be that expensive and most of the current solutions only shorten links, people still left with many questions unanswered. I wanted something that could fill in the blanks to the questions I had and many others do about how their links are actually performing? what they could be doing differently? and I wanted an solution that was more generous but I couldn't find one so... I built my own.

What makes it different (the technical bits)

Instead of just another CRUD app with redirects, I added AI that's actually useful:

Conversational analytics – Ask questions in plain English:

"Which link got the most clicks this week?"
"Is my landing page still up?"
"When's the best time to post my next link?"

No GraphQL queries. No SQL. Just ask and get answers with real data. Your data! your links/urls! your campaigns/products/videos! all these data sources will feed metrics into Shrinkify where users can derive actionable insights from to actually make decisive decisions.

Under the hood:

React 18 + TypeScript + Vite
Supabase for backend (Postgres + real-time subscriptions)
OpenAI API for conversational interface along with all the fancy models (ChatGPT, Claude, Gemini, and more)
ML models for predictive analytics
Edge functions for AI health monitoring

Other features devs will appreciate:

🔮 Predictive analytics (7/30/90-day forecasts)
🏥 Automated health monitoring with alerts
⚡️ AI slug generator (because naming is the hardest problem)
🔌 High-speed API access on premium is coming soon also
📊 CSV exports for your own analysis

Pricing (actually fair)

Free: 25 links, 10K clicks, basic AI
Pro: $9/mo (1k links, 100K clicks)
Premium: $99/mo (unlimited links, 1M clicks/mo, and all AI features)

Compare that to Bitly's $29/mo for basic features.

The tech stack

Frontend: React 18, TypeScript, Tailwind CSS, shadcn/ui, kibo UI
Backend: Supabase (Postgres + Edge Functions)
AI: OpenAI GPT-4 API, Gemini, Claude
Analytics: Custom ML models
Deployment: Vercel
Payments: Stripe

Open to questions about any of the architecture decisions.

Why I'm posting here

I'm indie building this. No VC money. No team. Just me and i'm having fun.

The code isn't perfect. There are probably bugs. But it's honest work and it actually solves a problem I had.

Would love feedback from this community:

Is the AI useful or gimmicky?
What features would you actually use?
What would make you switch from your current solution?

Try it out, break it, tell me what sucks: shrinkify.co

I'll be around to answer questions 🙏

⭐️ Shrinkify's Product Hunt Link: AI URL shortener that doesn't feel like a scam

P.S. - If you're curious about how I implemented the conversational AI or the predictive models, happy to write a deep-dive post.

Calculator Backend-API In Go

Jordan Tingling — Mon, 02 Dec 2024 00:18:00 +0000

Back again with another mini-project, this time with a calculator backend API tool written in Go!

I recently wrapped up a project to build an HTTP+JSON API for a stateless calculator, and let me tell you—it was a lot more fun (and a little more challenging) than I expected. On the surface, it might sound simple: “Hey, it’s just a calculator, right?” But once you dive in, you start uncovering all the nitty-gritty details that make an API truly production-ready.

So, let me share the process, the lessons learned, and what I’d tweak if I had to do it again.

~ Souce code: Found here

A Stateless Calculator API

The mission was straightforward: build an API for a calculator that doesn’t store any data—no databases, no in-memory caching. Every calculation happens in isolation. Stateless. Clean. Simple. The API follows an OpenAPI specification, which lays out all the endpoints and expected behaviors.

What's next?

Input Validation

One of the first lessons I learned was the importance of input validation. You can’t trust users, even with something as basic as math. For example:

What happens if someone sends in a non-number? Boom.
How about division by zero? Double boom.

To handle this, I made sure every input was sanitized and validated before the API even thought about processing it. If something was off, the user got a helpful, friendly error message like:

{
  "error": "Division by zero is not allowed. Please provide a valid denominator."
}

Nobody likes cryptic “500 Server Error” messages.

Logging for Debugging

You know that saying, “Logs are your best friend”? It’s true. I implemented structured logging using a Go golang.org/x/exp/slog package, and it saved me so much time. Every request was logged with details like:

The request path
The user’s IP address
The status code
Any errors that popped up

Here’s a snippet of how I set it up for text logs:

logger := slog.New(slog.NewTextHandler(os.Stdout, nil))

Or for JSON logs (which are great for integrating with monitoring tools):

logger := slog.New(slog.NewJSONHandler(os.Stdout, nil))

Having those logs handy made debugging a breeze when something didn’t work as expected.

CORS: An Unexpected Hero

I hadn’t initially planned for this API to be used in a browser-based app, but as the project evolved, it became clear that CORS (Cross-Origin Resource Sharing) was necessary.

Using the github.com/rs/cors package, I quickly added the required headers to allow browser-based clients to interact with the API.

c := cors.New(cors.Options{
        AllowedOrigins:   []string{"*"},
        AllowedMethods:   []string{"GET", "POST", "OPTIONS"},
        AllowedHeaders:   []string{"Content-Type"},
        AllowCredentials: true,
    })

My main packages

1) net/http: Go’s standard library for setting up the HTTP server and routing requests.
2) encoding/json: To handle JSON encoding/decoding for requests and responses.
3) golang.org/x/exp/slog: For logging every request in either text or JSON format.
4) github.com/rs/cors: To handle cross-origin requests for web integrations.

What about the calculation logic?

Well I made some handlers for these calculations, they are pretty basic in nature and primarily focus on the core functionality of calculations (Addition, Subtraction, Division & Multiplication).

//handlers.go

func AddHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a + b })
    }
}

func SubtractHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a - b })
    }
}

func MultiplyHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 { return a * b })
    }
}

func DivideHandler(logger *slog.Logger) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        handleOperation(logger, w, r, func(a, b float64) float64 {
            if b == 0 {
                panic("division by zero")
            }
            return a / b
        })
    }
}

Aside from this, handling my HTTP requests with the famous net/http package was straightforward and there are many examples out there of doing this in different ways. My case was very simple and I just needed to serve up some HTTP, handling the response writer and the request.

func LoggingMiddleware(next http.Handler, logger *slog.Logger) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        lrw := &loggingResponseWriter{ResponseWriter: w, statusCode: http.StatusOK}

        next.ServeHTTP(lrw, r)

        duration := time.Since(start)
        logger.Info("Request completed",
            "path", r.URL.Path,
            "method", r.Method,
            "status", lrw.statusCode,
            "duration", duration)
    })
}

type loggingResponseWriter struct {
    http.ResponseWriter
    statusCode int
}

func (lrw *loggingResponseWriter) WriteHeader(code int) {
    lrw.statusCode = code
    lrw.ResponseWriter.WriteHeader(code)
}

Here are some use-case examples:

// Start up server
// go run main.go

time=2024-12-01T19:11:47.777-05:00 level=INFO msg="Starting server on :3000"

time=2024-12-01T19:11:55.440-05:00 level=INFO msg="Request completed" path=/add method=POST status=200 duration=164.584µs

time=2024-12-01T19:12:51.520-05:00 level=INFO msg="Request completed" path=/subtract method=POST status=200 duration=124.875µs

time=2024-12-01T19:12:56.727-05:00 level=INFO msg="Request completed" path=/divide method=POST status=200 duration=40.875µs

time=2024-12-01T19:13:04.128-05:00 level=INFO msg="Request completed" path=/multiply method=POST status=200 duration=46.458µs

Requests:


// Addition
curl -d '{"a": 10, "b": 5}' http://localhost:3000/add
{"result":15}

// Subtraction
curl -d '{"a": 10, "b": 5}' http://localhost:3000/subtract
{"result":5}

// Division
curl -d '{"a": 10, "b": 5}' http://localhost:3000/divide  
{"result":2}

// Multiplication
curl -d '{"a": 10, "b": 5}' http://localhost:3000/multiply
{"result":50}

Conclusion

Yep! That's pretty much it! It was a quick and fun mini-project that I enjoyed! Feel free to give it a try and improve & enhance whichever way you'd like to.

Until next time, cheers! 🍻 🥂

Currency Converter In Go

Jordan Tingling — Sun, 01 Dec 2024 21:51:54 +0000

Hey Guys!

Yet another small mini-project for making a currency converter in Go!

It's a simple but fun project that should take someone about an hour or 2 depending on their experience. It takes a currency type from one end, the currency which we intend to convert to and the amount to be converted.

I'm making use of a third-party service (https://openexchangerates.org) to retrieve the latest currency data.

My Main base currencies are:

1) USD
2) EUR
3) GBP
4) JPY

and I also have support for "other" currencies through input in the TUI. Both for base currencies and currencies to be converted to.

~ Source Code: Found here

Let's Begin

What is your base currency?

                              List             

$ USD               
United States Dollar

£ GBP               
British Pound

€ EUR       
Euro        

¥ JPY       
Japanese Yen       


  •••

The main functionalities of the application are:

Get Conversion details entered by the user
Use those details and send an API request to Openxchangerates (Third-Party service with the latest currency conversion rates)
Convert currencies & amount
Output currencies & amount data to the user

The packages used:

net/http - for http requests to the currency exchange api
github.com/charmbracelet/huh - for the TUI interface form
github.com/charmbracelet/bubbles/list - feature-rich for browsing a general-purpose list of items
encoding/json - in order to marshal the data for the API
github.com/charmbracelet/lipgloss - Style definitions for terminal layouts

How does it work?

So let's discuss the first bit of functionality, which is getting conversion details from the user.

A view method for getting this user-provided data had to be made and it asks the user questions on what currency to convert, which currency to be converted to, and more.

func (m model) View() string {
    if m.err != nil {
        return fmt.Sprintf("Error: %v\n\nPress any key to continue.\n", m.err)
    }

    if m.finished {
        // Return an empty string when finished to avoid redundant output.
        return ""
    }

    switch m.stage {
    case 0:
        if m.isCustomInput {
            return questionStyle.Render("Enter your custom base currency code (e.g., USD):\n\n") + m.textInput.View()
        }
        return questionStyle.Render("What is your base currency?\n\n") + m.list.View()
    case 1:
        if m.isCustomInput {
            return questionStyle.Render("Enter your custom target currency code (e.g., EUR):\n\n") + m.textInput.View()
        }
        return questionStyle.Render("What do you want to convert to?\n\n") + m.list.View()
    case 2:
        return questionStyle.Render("How much to convert?\n\n") + m.textInput.View()
    default:
        return ""
    }
}

What do you want to convert to?

                                  List             

$ USD               
United States Dollar

£ GBP               
British Pound       


  •••

How much to convert?

                    > 200

Now let's discuss the second point, using the currency conversion details and sending an API request to Openxchangerates.

Here I'm getting/fetching for the latest currency rates from Openxchangerates.org via an API key provided by the third-party currency exchange platform. In my case, I made use of .env's for secret management but there are a multitude of other ways to better handle this, especially if it were a production app.

~ Openxchangerates.org docs used for this: located here

//api.go

package api

import (
    "encoding/json"
    "fmt"
    "net/http"
)

type CurrencyData struct {
    Base  string             `json:"base"`
    Rates map[string]float64 `json:"rates"`
}

func FetchRates(apiKey string) (CurrencyData, error) {
    url := fmt.Sprintf("https://openexchangerates.org/api/latest.json?app_id=%s&prettyprint=false", apiKey)
    resp, err := http.Get(url)
    if err != nil {
        return CurrencyData{}, err
    }
    defer resp.Body.Close()

    if resp.StatusCode != 200 {
        return CurrencyData{}, fmt.Errorf("API request failed with status: %s", resp.Status)
    }

    var data CurrencyData
    err = json.NewDecoder(resp.Body).Decode(&data)
    if err != nil {
        return CurrencyData{}, err
    }

    return data, nil
}

Then we'll proceed with converting the currencies and amounts:

//conversion.go

package conversion

func Convert(amount float64, rateFrom, rateTo float64) float64 {
    return amount * (rateTo / rateFrom)
}

which is simply taking in a base amount (amount), a rate from the base currency and the rate to be converted to and returns a final converted amount.

Lastly, providing the converted currencies and amount-related data back to the user.

Controlling the logic behind these selections is an update function that serves as the main state transition handler for the application's model.

func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
    var cmd tea.Cmd

    switch msg := msg.(type) {
    case tea.KeyMsg:
        key := msg.String()
        switch key {
        case "enter":
            if m.isCustomInput {
                // Handle custom currency input
                input := strings.ToUpper(strings.TrimSpace(m.textInput.Value()))
                if !isAlphabetic(input) || len(input) != 3 {
                    m.err = fmt.Errorf("invalid currency code: must be 3 letters")
                    return m, nil
                }
                if m.stage == 0 {
                    m.currencyFrom = input
                    m.isCustomInput = false
                    m.textInput.Reset()
                    m.stage++
                    m.list.ResetSelected()
                    return m, nil
                } else if m.stage == 1 {
                    m.currencyTo = input
                    m.isCustomInput = false
                    m.textInput.Reset()
                    m.stage++
                    m.textInput.Placeholder = "Enter amount (e.g., 100)"
                    m.textInput.Focus()
                    return m, nil
                }
            } else if m.stage == 2 {
                // Handle amount input
                amountStr := strings.TrimSpace(m.textInput.Value())
                amount, err := strconv.ParseFloat(amountStr, 64)
                if err != nil {
                    m.err = fmt.Errorf("invalid amount: %v", err)
                    return m, nil
                }
                m.amount = amount
                m.finished = true
                return m, tea.Quit
            } else {
                // Handle list selection
                selectedItem := m.list.SelectedItem().(Item)
                if selectedItem.Code == "OTHER" {
                    m.isCustomInput = true
                    m.textInput.Placeholder = "Enter currency code (e.g., USD)"
                    m.textInput.Focus()
                    return m, textinput.Blink
                }
                if m.stage == 0 {
                    m.currencyFrom = selectedItem.Code
                    m.stage++
                    m.list.ResetSelected()
                    return m, nil
                } else if m.stage == 1 {
                    m.currencyTo = selectedItem.Code
                    m.stage++
                    m.textInput.Placeholder = "Enter amount (e.g., 100)"
                    m.textInput.Focus()
                    return m, nil
                }
            }
        case "ctrl+c", "esc":
            return m, tea.Quit
        }
    }

    // Handle text input for custom currency or amount input
    if m.isCustomInput || m.stage == 2 {
        m.textInput, cmd = m.textInput.Update(msg)
        return m, cmd
    }

    // Handle list updates for currency selection
    if m.stage == 0 || m.stage == 1 {
        m.list, cmd = m.list.Update(msg)
        return m, cmd
    }

    return m, nil
}

// go run main.go
200.00 EUR = 166.03 GBP

Conclusion

That pretty much wraps up this relatively quick currency converter. I hope you've enjoyed the quick read and feel free to give a shot also, it's not that bad! 😁.

Feel free to also experiment with other third-party currency exchange providers out there, there are many. Hopefully, they got a decent API too!

See you guys on the next one! 👋🏼

URL Shortener in Go

Jordan Tingling — Thu, 28 Nov 2024 04:11:54 +0000

Building URL Shorteners in Go: A Tale of Two Frameworks

URL shorteners are a classic example of how simple tools can make a big impact. Whether you’re sharing links on social media or sending them in a text, shorter URLs are easier to manage and look clean.

In this blog post, I’ll walk you through these two URL shortener projects that are lightweight and very quick to create, they are both built-in Go: one using the Gin framework and the other using Gorilla Mux.

Each brings a unique approach to the table, and I’ll highlight their features and differences.

~ Source Code: Found here

URL Shortener with GUI: Feature-Rich and Intuitive

Let’s start with the first project—a URL shortener that goes beyond a simple API. It includes both a REST API backend and a desktop GUI application, making it accessible for developers and non-technical users alike. This project uses the Gin framework for its backend and Fyne for the GUI.

Key Features

REST API Backend

The Gin framework powers a fast and reliable API for shortening and redirecting URLs. It’s lightweight yet robust, perfect for this use case.
Desktop GUI

Built with the Fyne framework, the GUI is clean, minimalistic, and easy to use. It enables users to shorten URLs without needing to touch a terminal.
Secure and Random Keys

The short URLs are generated using secure random values, ensuring uniqueness and reducing the chances of collisions.
Dual Access

Whether you’re comfortable with REST APIs or prefer a GUI, this project has you covered.

Getting Started

To get started, clone the repository and install the necessary external Go packages:

git clone https://github.com/SirTingling/cloudprojects.git
cd url-shortener
go get -u github.com/gin-gonic/gin
go get -u fyne.io/fyne/v2

Running the App

Backend Server

Run the backend server with:

go run server.go

The server will start at http://localhost:8080.

Desktop GUI

Launch the GUI application with:

go run gui.go

This opens a simple window where you can input long URLs and get shortened links in return.

How does it work?

API Endpoints:

POST /shorten: Accepts a long URL and returns a short URL.
GET /:short: Redirects the short URL to the original URL.

GUI Workflow:

Enter the long URL.
Click "Shorten URL".
Copy the shortened link and share it.

The inclusion of a GUI makes it more versatile than a typical backend-only application.

URL Shortener V2: Lightweight and Straightforward

The second project is all about simplicity. Built with Gorilla Mux, it focuses on providing a basic yet functional URL shortener. If you’re looking for a lightweight solution that gets the job done, this is the one, my friends.

Key Features

Gorilla Mux for Routing

Gorilla Mux is a powerful router for Go, and it’s used here to handle all the HTTP endpoints.

MD5-Based Key Generation

Shortened URLs are created using an MD5 hash of the original URL. Yes, I do agree, that it’s not as secure as random generation, nevertheless, it’s efficient and ensures deterministic results.

In-Memory Storage

The shortener uses a simple in-memory map to store URLs. This makes it fast, though it’s not ideal for production-scale applications.

Minimal Dependencies

With only Gorilla Mux as an external dependency, this project is easy to set up and deploy.

Let's Go!

git clone <repository-url>
cd url-shortener
go get -u github.com/gorilla/mux

Running the App

Start the server with:

go run main.go

The server will run at http://localhost:8080.

How It Works

Create Short URL:

Send a POST request to /create with the url parameter:

curl -X POST -d "url=https://example.com" http://localhost:8080/create

Response:

http://localhost:8080/abcde

Redirect: Access the shortened URL

curl http://localhost:8080/abcde

This redirects to the original URL.

Honestly, it’s quick to implement and works well as a learning project or for small-scale use cases. I liked it as a quick mini-project.

Comparing the Two Approaches

Here’s a quick breakdown of the differences:

Feature	URL Shortener with GUI (Gin)	URL Shortener V2 (Mux)
Framework	Gin	Gorilla Mux
Frontend	Desktop GUI (Fyne)	None
URL Key Generation	Secure Random Values	MD5 Hash
Storage	Not Specified	In-Memory
Complexity	Moderate	Simple

Working with both approaches was straightforward in my personal opinion and I hope you guys will give them both a try as they can both be used in many different scenarios outside of URL shortening.

The Gin-based solution is ideal for those who want an all-in-one tool with a user interface, while the Mux-based version is perfect for lightweight, API-only use cases.

Thanks for tuning in again to my mini-project adventure with Go (and many more languages & tools). I'll catch you guys in the next one! Cheers!! 🥂

Simple Go CLI-Todo App

Jordan Tingling — Wed, 27 Nov 2024 23:44:56 +0000

Hey Guys!

I haven't blogged on Dev in over 2 years! It's been a while so please excuse me if my typing skills have degraded over time.

I'm currently learning Go and received a list of projects to complete and share, one of these happens to be a simple Golang cli-todo app that allows someone to add todos to a list of tasks and achieve a set of basic functionality on these tasks.

These include:

1) Listing Tasks
2) Adding More Tasks
3) Modifying These Tasks
4) Making Tasks Completed

Unfortunately, I don't have a fancy name for it 😅 as it's designed to be a lightweight, easy-to-use app that someone can complete in a day. Even if you're a beginner.

~ Project Source code: https://github.com/SirTingling/cloudprojects/tree/main/go-cli-todo-app

Let's Begin

Well as usual, the creation of our main.go. Once this is setup, we will need to define the structure and functionality of our todos. I did so in a separate todo.go

type Todo struct {
    Title       string
    Completed   bool
    CreatedAt   time.Time
    CompletedAt *time.Time
}

with a slice to hold our todos

type Todos []Todo

Then we'll need the implementation of the main methods of functionality, which include:

func (todos *Todos) add(title string) {
    todo := Todo{
        Title:       title,
        Completed:   false,
        CompletedAt: nil,
        CreatedAt:   time.Now(),
    }

    *todos = append(*todos, todo)
}

Creates a Todo object with a title, sets its Completed status to false, and appends it to the Todos slice.

delete

func (todos *Todos) delete(index int) error {
    t := *todos

    if err := t.validateIndex(index); err != nil {
        return err
    }

    *todos = append(t[:index], t[index+1:]...)

    return nil
}

Validates the index, then uses slicing to remove the item from the Todos list.

toggle

func (todos *Todos) toggle(index int) error {
    if err := todos.validateIndex(index); err != nil {
        return err
    }

    t := *todos
    todo := &t[index]

    if !todo.Completed {
        completedTime := time.Now()
        todo.CompletedAt = &completedTime
    } else {
        todo.CompletedAt = nil
    }

    todo.Completed = !todo.Completed
    return nil
}

Validates the index, flips the Completed boolean, and updates the CompletedAt timestamp accordingly.

The rest of the methods follow a very similar functionality, if any issues, feel free to check out the source code

Running The App

A common issue with many to-do apps that are cli-based is that they aren't as charming. With the help of a third-party package called aquasecurity/table the to-do list will be displayed neatly.

aquasecurity/table

It can be installed with:

go get github.com/aquasecurity/table

Then I made a method to display the todos using methods from external the package. Particularly SetRowLines, SetHeaders, New, AddRow & Render were the primarily used ones in my case.

func (todos *Todos) print() {
    table := table.New(os.Stdout)
    table.SetRowLines(false)
    table.SetHeaders("#", "Title", "Completed", "Created At", "Completed At")

    for index, t := range *todos {
        completed := "❌"
        completedAt := ""

        if t.Completed {
            completed = "✅"
            if t.CompletedAt != nil {
                completedAt = t.CompletedAt.Format(time.RFC1123) //time standard
            }
        }

        table.AddRow(strconv.Itoa(index), t.Title, completed, t.CreatedAt.Format(time.RFC1123), completedAt)
    }

    table.Render()
}

The print method is a neat way to show the list of todos in the terminal. It creates a table with columns for things like the task number, title, whether it's completed, when it was created, and when it was completed.

It goes through each todo item, checks if it's done or not, and adds a ✅ if it's completed or a ❌ if it isn't. If the task is finished, it even shows the exact date and time it was completed.

Once all the rows are ready, it prints the table out in a clean, readable format. Super handy for quickly seeing the status of all a user's tasks at a glance!

How about saving these todos?

So I thought that the functionality of saving the todos locally to let's say a file, in this case, todos.json, and then reading from there would be a good idea. Essentially having some level of persistence of our data regarding each and all todos.

We could add this functionality to an existing file, but I think it's a good idea to separate concerns.

I added a storage.go, it could be called whatever you'd like store.go, persist.go, etc.

I chose JSON but the same principles usually apply to any data format you'd like to save the data too.

package main

import (
    "encoding/json"
    "os"
)

type Storage[T any] struct {
    Filename string
}

func NewStorage[T any](filename string) *Storage[T] {
    return &Storage[T]{Filename: filename}
}

func (s *Storage[T]) Save(data T) error {
    fileData, err := json.MarshalIndent(data, "", "    ")
    if err != nil {
        return err
    }

    return os.WriteFile(s.Filename, fileData, 0644) // file mode
}

func (s Storage[T]) Load(data *T) error {
    fileData, err := os.ReadFile(s.Filename)
    if err != nil {
        return err
    }

    return json.Unmarshal(fileData, data) // convert and populate data
}

There's a Storage struct that keeps track of the file being worked with.
The NewStorage function helps set things up by just giving it the file name.
The Save method takes the data, turns it into pretty JSON, and writes it to the file (todos.json). If something goes wrong, it tells us with an error.
The Load method does the opposite—reads the file, unpacks the JSON, and fills the fileData with the data.

It’s an easy, reusable way to handle saving and loading any kind of data without needing a database or anything fancy.

From here I make use of the NewStorage in the main.go to add some todos to my list and save them which can now be viewed in my todos.json

func main() {
    todos := Todos{}
    // Load data (todos) from storage:
    storage := NewStorage[Todos]("todos.json")
    err := storage.Load(&todos)
    if err != nil {
        fmt.Println("Warning: Could not load todos from storage. Starting fresh todos.")
    }
    // Parse & Execute
    cmdFlags := NewCmdFlags()
    cmdFlags.Execute(&todos)
    // Save to storage
    err = storage.Save(todos)
    if err != nil {
        fmt.Printf("Error saving todos in storage: %v\n", err)
    }
}

[
    {
        "Title": "Go for a drive",
        "Completed": false,
        "CreatedAt": "2024-11-26T15:26:06.691069-05:00",
        "CompletedAt": null
    },
    {
        "Title": "Eat dinner",
        "Completed": true,
        "CreatedAt": "2024-11-26T15:26:37.361324-05:00",
        "CompletedAt": "2024-11-26T15:33:03.088908-05:00"
    },
    {
        "Title": "Walk my dog",
        "Completed": false,
        "CreatedAt": "2024-11-27T17:44:04.963474-05:00",
        "CompletedAt": null
    },
    {
        "Title": "Go hiking later with ashley",
        "Completed": false,
        "CreatedAt": "2024-11-27T17:51:01.667686-05:00",
        "CompletedAt": null
    }
]

For the commands, I didn't make anything fancy. I defined the flags I'll use as a struct

type CmdFlags struct {
    Add    string
    Del    int
    Edit   string
    Toggle int
    List   bool
}

then a simple function using the flag package the list these flags, give them more details & descriptions, and customize them. I've also heard good things about the Cobra package which could be very easy to use here, next time I'll try it out.

func NewCmdFlags() *CmdFlags {
    cf := CmdFlags{}

    // Flag list and usage of cli todo app
    flag.StringVar(&cf.Add, "add", "", "Add a new todo specifying title")
    flag.StringVar(&cf.Edit, "edit", "", "Edit a todo by index & specify a new title. id:new_title")
    flag.IntVar(&cf.Del, "del", -1, "Specify a todo by index to delete effectively")
    flag.IntVar(&cf.Toggle, "toggle", -1, "Specify a todo by index to toggle")
    flag.BoolVar(&cf.List, "list", false, "List all todos")
    //
    flag.Parse()

    return &cf
}

From there, you can get creative on how you'd like to execute these flags, in my case I made simple case statements.

That's It?

Yep! That completed this simple Go cli to-do app that can be done in a relatively short period of time, major shout out to Coding with Patrik and The Builder both of which have amazing content out there for helping with projects like these and making it fun!

Thanks for reading and I hope that these mini-projects inspire others to either get started with Go or simply keep practicing with it. I have a few more to do and share, see you guys next time!

Git CheatSheet

Jordan Tingling — Sun, 02 Oct 2022 02:02:16 +0000

Git (Version Control)

Git is an essential collaborative part of any programmer/developer/DevOps engineer's daily routine. Git is widely used in the industry with version control platforms such as Github, Bitbucket, etc.

There is a multitude of commands to use for Git; mastering them takes time and effort. In this post, my aim is to share with you some of the more frequently used commands in Git that every developer should know.

Git Clone

Git clone is a command that is used for downloading existing source code from a remote repository (Github, Bitbucket). Basically, git clone makes an identical copy of the latest version of a project in a repository and saves it within your local filesystem on your local machine.

Generally, I clone with https:

git clone <https://name-of-the-repository-link>

This will make a copy of the repository to your local machine so you can start working with it, make changes, etc.

Git branch

By making use of branches in Git, several developers are able to work in parallel on the same project simultaneously. We can use the git branch command for creating, listing, and deleting branches.

Creating a new branch:

This command will create a branch locally.

git branch <branch-name>

To push the new branch into the remote repository, here is the command to use:

git push -u <remote> <branch-name>

Viewing branches:

git branch or git branch --list

Delete a branch:

git branch -d <branch-name>

Git checkout

This is also one of the most used Git commands. In order to work in a branch, we first need to switch to that branch. We use git checkout mainly for switching from one branch to another. It can also be used for checking out files and commits.

git checkout <name-of-your-branch>

The changes in your current branch must be committed or stashed before you switch
The branch you want to checkout should already exist in your local directory.

Here is a shortcut command that will allow you to create and switch to a branch at the same time:

git checkout -b <name-of-your-branch>

This command creates a new branch in your local (-b means for branch) and checks the branch out to new right after it has been created.

Git status

The Git status command gives all the necessary information about the current branch.

git status

This information is very important, it provides:

Info on whether the current branch is up to date
Info on anything to commit, push or pull
Info on files stages, unstaged or untracked.
Info on files created, modified, or deleted.

Git add

Whenever we create, modify, or delete a file, these changes will happen in our local and will not be included in the enxt commit.

we need to use the git add command to include the changes of a file(s) into our next commit.

Add a single file:

git add <file>

Add everything at once:

git add -A

The git add command doesn't change the repository and the changes are not saved until we make use of git commit

Git commit

The famous Git commit command is probably the most used command of Git. To save our changes we make use of git commit.

Git commit is like setting a checkpoint in the development process which you can go back to later if needed.

We are able to write a short message explaining what you have developed or changes in the source code.

git commit -m "commit message

PS: Git commit saves your changes only locally

Git push

Making use of Git push is for sending your changes to the remote server (remote repository) after committing your changes.

git push <remote> <branch-name>

If your branch is newly created, please upload the branch with the following command:

git push --set-upstream <remote> <name-of-your-branch>

git push -u origin >branch-name>

PS: Git push only uploads changes that have been committed

Git pull

The git pull command is used to get updates from the remote repository. This command is basically a combination of git fetch and git merge which means that, when we use git pull, it gets the updates from the remote repository (git fetch) and immediately applies the latest changes in your local (git merge).

git pull <remote>

Git revert

The git revert command is used to undo the changes that we've made.

To see your commit history, make use of this command: git log --oneline

Specify the hash code next to your commit that you would like to undo:

Example: 4442389

git revert 4442389

The Git revert command will undo the given commit, but will create a new commit without deleting the older one.

The advantage of using git revert is that it doesn't do anything to the commit history. Also, everything happens in our local system unless we push it to the remote repository.

Git merge

Once you have completed development in your branch and everything works as intended, the final step is to merge the local branch with the parent branch (remote branch). This can be accomplished with the git merge command.

Before merging, you should update your local development branch:

git fetch

Then, we can merge your feature branch into the remote branch:

git merge <branch-name>

PS: Please ensure your local development branch has the latest version before you merge your branches, otherwise, you may face conflicts or other unwanted issues with versioning and state control

I hope these frequently used Git commands will help all developers in their daily tasks. There are many more things to learn about Git and complex ways of versioning, therefore, I encourage you to continue learning Git and take things future.

Thank you @CemEygi

Pass The AWS Certified Solution Architect - Associate (SAA-CO3)

Jordan Tingling — Sun, 28 Aug 2022 02:27:00 +0000

I passed the AWS Certified Solutions Architect — Associate exam (SAA-C02) on Nov 12, 2021. SA-associate

~ Please right-click and "open link in new tab" for all links

By Aug 30, 2022, the (SAA-C02) version of the exam will be retired and the (SAA-CO3) will be the new version of the exam, however, all information and resource that I will be providing will prepare you for the new version of the exam (SAA-CO3).

This post was written to help my dad (you got this pops!) pass the certification, however, it's not exclusive to my dad and can be taken advantage of by anyone interested in the AWS Certified Solutions Architect — Associate exam (SAA-C03) including his co-workers that are also interested in passing this cert.

First Steps

Well, the starting point for me was the exam guide which is located on the main page of the exam where you could also download the sample questions that AWS provides.

The next thing I did was begin collecting relevant resources I plan to use for studying. Try to have all the necessary resources stored in one place.

Establish Your Learning Path/Resources

From all the resources you collected, try to establish your learning path, based on your experience and the time you plan to invest. There are plenty of courses on learning platforms such as Udemy, Cloud Academy, A Cloud Guru, etc. Try to pick one of the courses. After I tried several ones, I made the decision of taking A Cloud Guru's AWS Certified Solutions Architect - Associate (SAA-C02) course, and don't worry, they have updated the course to match the new version of the exam (SAA-C03). It's a great choice for someone that doesn't have the most time and needs an interactive way of learning by doing hands-on labs, quizzes, etc. A Cloud Guru is a paid subscription company that offers multiple plans, I recommend the personal Plan-Basic. For this certification that is more than enough, however, if you need more then they have it for you!

For the persons that have more time on their hands >45.9 hours of content and desire a deeper understanding of the technologies and services within the certification to not only the certification but truly understand them on a deeper level then I definitely recommend Adrian Cantrill's course AWS Certified Solutions Architect - Associate (SAA-C03. Adrain's course is a one-time fee of $40, however, his learning material is impeccable, I recommend his course material to anyone at any stage of their journey to cloud & AWS!

What I find also useful is the Tutorials Dojo SAA-C03 study path, with the list of all the useful resources. On that page. Also, try to read the AWS Well architectures framework and other major whitepapers related to the SAA-C03.

You can also take the official AWS training for this exam if possible, but it is a matter of preference. Someone is more comfortable with official training and dedicated time, and someone is more comfortable going with an online course, at your own pace.

Let The Learning Begin

Whatever you picked, dedicate some time to go through all the topics, even if it's 2-3 hours a day, by the end of the week that's 14-21 hours dedicated to studying for the most popular IT certification in 2022. It is not required, however, I do recommend writing specific notes from the lectures, because it is a lot of stuff. You will come back later to the notes, trust me. Try not just to go through materials, but also try to get your hands dirty with AWS stuff, and gather some hands-on experience. There are plenty of possibilities in the AWS Free Tier.

Scheduling The Exam

I personally didn't schedule my exam until I had completed all my learning, hands-on, practice exams, etc. However, everyone is different, therefore you could schedule your exam after a few days (7–14) when you see how are you progressing, this is not required, only an option for those that want to hold themselves accountable. Doing so can help determine a learning pace for you.

Vouchers and Providers

You have basically 2 providers for scheduling the exam:

Pearson VUE
PSI

I immediately recommend Pearson VUE, trust me. Pearson VUE provides taking the exam online and I wanted to take it from home. I have tried PSI in the past and even to this date, they are a headache for me.

Additional Time - Extra 30 Mins

If you are not a native English speaker, you can get yourself an extra 30 minutes for taking an exam. I found this really useful, however, I do speak English as my native language and didn't feel I needed the extra time. You can request this via Exam accommodations, and pick ESL + 30 MINUTES one.

Push Through

When going through the resources, be sure you understand all the topics. If you don’t, check it again or try to search for an answer. Try to keep notes of all relevant pieces of information. The SAA-C03 covers a vast area of topics. Be sure that you master these topics to the best of your ability, Here is a short list of major topics in the SAA-C03:

EC2 – As the most fundamental compute service offered by AWS, you should know about EC2 inside out.
Lambda – Lambda is the common service used for serverless applications. Study how it is integrated with other AWS services to build a full-stack serverless app.
Elastic Load Balancer – Load balancing is very important for a highly available system. Study the different types of ELBs, and the features each of them supports.
Auto Scaling – Study what services in AWS can be auto-scaled, what triggers scaling, and how auto-scaling increases/decreases the number of instances.
Elastic Block Store – As the primary storage solution of EC2, study the types of EBS volumes available. Also study how to secure, backup, and restore EBS volumes.
S3 / Glacier – AWS offers many types of S3 storage depending on your needs. Study what these types are and what differs between them. Also review the capabilities of S3 such as hosting a static website, securing access to objects using policies, lifecycle policies, etc. Learn as much about S3 as you can.
Storage Gateway – There are occasional questions about Storage Gateway in the exam. You should understand when and which type of Storage Gateway should be used compared to using services like S3 or EBS. You should also know the use cases and differences between DataSync and Storage Gateway.
EFS – EFS is a service highly associated with EC2, much like EBS. Understand when to use EFS, compared to using S3, EBS, or instance store. Exam questions involving EFS usually ask about the trade-off between cost and efficiency of the service compared to other storage services.
RDS / Aurora – Know how each RDS database differs from one another, and how they are different from Aurora. Determine what makes Aurora unique, and when it should be preferred over other databases (in terms of function, speed, cost, etc). Learn about parameter groups, option groups, and subnet groups.
DynamoDB – The exam includes lots of DynamoDB questions, so read as much about this service as you can. Consider how DynamoDB compares to RDS, Elasticache and Redshift. This service is also commonly used for serverless applications along with Lambda.
Elasticache – Familiarize yourself with Elasticache Redis and its functions. Determine the areas/services where you can place a caching mechanism to improve data throughput, such as managing the session state of an ELB, optimizing RDS instances, etc.
VPC/NACL/Security Groups – Study every service that is used to create a VPC (subnets, route tables, internet gateways, nat gateways, VPN gateways, etc). Also, review the differences between network access control lists and security groups, and during which situations they are applied.
Route 53 – Study the different types of records in Route 53. Study also the different routing policies. Know what hosted zones and domains are.
IAM – Services such as IAM Users, Groups, Policies, and Roles are the most important to learn. Study how IAM integrates with other services and how it secures your application through different policies. Also, read on the best practices when using IAM.
CloudWatch – Study how monitoring is done in AWS and what types of metrics are sent to CloudWatch. Also read up on Cloudwatch Logs, CloudWatch Alarms, and the custom metrics made available with CloudWatch Agent.
CloudTrail – Familiarize yourself with how CloudTrail works, and what kinds of logs it stores as compared to CloudWatch Logs.
Kinesis – Read about Kinesis sharding and Kinesis Data Streams. Have a high-level understanding of how each type of Kinesis Stream works.
CloudFront – Study how CloudFront helps speed up websites. Know what content sources CloudFront can serve from. Also, check the kinds of certificates CloudFront accepts.
SQS – Gather info on why SQS is helpful in decoupling systems. Study how messages in the queues are being managed (standard queues, FIFO queues, dead letter queues). Know the differences between SQS, SNS, SES, and Amazon MQ.
SNS – Study the function of SNS and what services can be integrated with it. Also, be familiar with the supported recipients of SNS notifications.
SWF / CloudFormation / OpsWorks – Study how these services function. Differentiate the capabilities and use cases of each of them. Have a high-level understanding of the kinds of scenarios they are usually used in.

Practice Exams

No matter how many times you listen for the video course, it is really hard to pass the exam without trying to solve practice exams. Do the practice exams! If you chose to complete A Cloud Guru's AWS Certified Solutions Architect - Associate (SAA-C02) course, they provide 1 practice exam. However, the best practice exams for the SAA-C03 are provided by John Bonso's Tutorial Dojo AWS Certified Solutions Architect Associate Practice Exams SAA-C02/SAA-C03 2022. They provide 6 practice exams that are made to be more difficult than the actual AWS SAA-C03 exam and in my opinion, they definitely are. I have used Tutorial Dojo's practice exam to prepare for all my certifications so far, they are highly recommended by me!

For all the certificates I passed so far, I had worse results on the practice exams than on the real exam. That was also the case with this one.

Once you are done with a practice exam, try to revisit all the questions and explanations. When I say all, I mean the ones with correct and incorrect answers. Try to memorize some important facts you notice from the explanations. That will probably be useful for the exam. Do all of the practice exams.

Be aware of the words cost-efficient, cost-optimized, high availability, fault tolerance! Your answers are depending on these words.

Leading Up To The Exam

When going to the exam, try to follow all the instructions you received in the confirmation mail. When you start, try to organize your time when going through the exam.

The Pass/Fail status you should get immediately, and score report in a day.

Special Note: You got this dad, you already know the concepts, just learn the AWS way of doing things and pay special attention to certain keywords, phrases and use cases of services.

Thank you for reading and I hope this has helped whomever reading to achieve their AWS Certified Solutions Architect — Associate exam (SAA-C03) certification.

Do we really need AWS?

Jordan Tingling — Tue, 24 May 2022 04:59:02 +0000

Honestly, do we really need AWS?

Short answer, simply YES!! we do. The ease of mind and cost that AWS and other cloud providers offer is simply nothing short of spectacular. We also have layers and layers of security to protect even government official data, bank data and personally identifiable data (PID). ALL of that for a simple monthly / semi-annual / annual fee that is not stagnant. You pay-as-you-go, which simply means, the more you use or require to use, then the more you pay. The best and also possibly the worst part of this model is the cost, if you know what you are doing or have a team of professionals managing your infrastructure then you can greatly minimize your cost compared to that of creating, setting & configuring your own IT department / IT infrastructure and employing personnel, purchasing hardware, etc.

However, if you have no clue what you are doing, you can put yourself or business into a financial deficit. Automatic Auto Scaling can be disabled to give the users more control etc but the point is, know what you are doing when you enter the field of cloud computing (AWS / Azure / GCP) or get in contact with people who do.

What is AWS?

AWS is made up of many different cloud computing products and services. The highly profitable division of Amazon provides servers, storage, networking, remote computing, email, mobile development, and security. AWS can be broken into three main products: EC2, Amazon’s virtual machine service, Glacier, a low-cost cloud storage service, and S3, Amazon’s storage system.

AWS is so large and present in the computing world that it's far outpaced its competitors. As of the first quarter of 2021, one independent analyst reports AWS has over a third of the market at 32.4%, with Azure following behind at 20%, and Google Cloud at 9%.

AWS has 81 availability zones in which its servers are located. These serviced regions are divided in order to allow users to set geographical limits on their services (if they so choose), but also to provide security by diversifying the physical locations in which data is held. Overall, AWS spans 245 countries and territories.

PS: These percentages are probably a bit out of date but you get the big picture, AWS is still the king.

Cost Savings with AWS

Amazon took a refreshing approach to pricing its hosting when launching AWS. Every service is "a la carte", meaning you pay for what you use. This makes a lot of sense for server infrastructure, as traffic tends to be very bursty, especially the larger the site is.

Traditional hardware, for the most part, goes unutilized for 90% of its lifecycle. AWS helps deal with this problem by keeping it cheap during the slow times.

Scaling with AWS

As I said earlier, scaling can be wonderful but educate yourself on how to properly scale efficiently based on your requirements or get someone who can perform these tasks for you.

Since AWS’s cost is modified based on the customers’ usage, start-ups and small businesses can see the obvious benefits of using Amazon for their computing needs. In fact, AWS is great for building a business from the bottom as it provides all the tools necessary for companies to start up with the cloud. For existing companies, Amazon provides low-cost migration services so that your existing infrastructure can be seamlessly moved over to AWS.

As a company grows, AWS provides resources to aid in expansion. As the business model allows for flexible usage, customers will never need to spend time thinking about whether or not they need to reexamine their computing usage. In fact, aside from budgetary reasons, companies could realistically “set and forget” all their computing needs.

Can we trust AWS with our data?

Arguably, Amazon Web Services (AWS) is much more secure than a company hosting its own website or storage. AWS currently has dozens of data centers across the globe that are continuously monitored and strictly maintained. The diversification of the data centers ensures that a disaster striking one region doesn’t cause permanent data loss worldwide. Imagine if Netflix were to have all of its personnel files, content, and backed-up data centralized on-site on the eve of a hurricane. Chaos would ensue.

In fact, localizing data in an easily identifiable location and where hundreds of people can realistically obtain access is unwise. AWS has tried to keep its data centers as hidden as possible, locating them in out-of-the-way locations and allowing access only on an essential basis.

The data centers and all the data contained therein are safe from intrusions, and, with Amazon’s experience in cloud services, outages and potential attacks can be quickly identified and easily remedied, 24 hours a day. The same can’t be said for a small company whose computing is handled by a single IT specialist working out of a large office.

Conclusion

The most important feature in AWS is its flexibility. All the services work and communicate together with your application to automatically judge demand and handle it accordingly.

Combined with the fantastic API and the Amazon Machine Images you create, you can have a completely customized solution that provisions a server instance in under 10 minutes, and is ready to to accept connections once it comes online. Then you can quickly shut down instances when they are no longer needed, making server management a thing of the past.

AWS is my cloud provider of choice, however, Azure & GCP are both incredible cloud providers, each with their own advantages and disadvantages compared to AWS. My advice is to find one and stick with it and then understand another if you so choose too.

There are so many resources out nowadays to help people get started in AWS or resources for experienced cloud individuals as well.

Beginners - intermediate:
A Cloud Guru This is where I began my journey by completing my Certified Cloud Practitioner Certification. I recommend them highly for newbies but for people with more experience, I still do recommend them but I have a certain person by the name of Adrian Cantrill that is better at getting more detailed with AWS services.

Intermediate - Advanced:
Adrian Cantrill Without this guy, I definitely couldn't have passed any associate level certification. For those just starting out in AWS, I do recommend him, however, take note that his courses are very detailed, not cheap and 100% worth it.

For those who want a crash course and do not want to spend money just yet or at all, I have a few options that are 100% FREE:
AWS Skill Builder These are free lessons offered by AWS themselves.
AWS Certified Cloud Practitioner Certification Course (CLF-C01) - Pass the Exam! offered by FreeCodeCamp.

Thanks for tuning in, see you again next time!

What does it mean to truly be Server-Less (Serverless)

Jordan Tingling — Fri, 20 May 2022 02:56:39 +0000

Serverless? What's this all about?

Serverless computing, or more simply Serverless, is a hot topic in the software architecture world. The “Big Three” cloud vendors—Amazon, Google, and Microsoft—are heavily invested in Serverless, and we’ve seen plenty of books, open-source projects, conferences, and software vendors dedicated to the subject. But what is Serverless, and why is (or isn’t) it worth considering?

OOHH! It most definitely is worth considering, in-fact allow me to explain to you why.

Serverless was first used to describe applications that significantly or fully incorporate third-party, cloud-hosted applications and services, to manage server-side logic and state. Serverless can also mean applications where server-side logic is still written by the application developer, but, unlike traditional architectures, it’s run in stateless compute containers that are event-triggered, ephemeral (may only last for one invocation), and fully managed by a third party.

Okay I get it but can this Serverless thing actually save me money?

Serverless can be more cost-effective than renting or purchasing a fixed quantity of servers, which generally involves significant periods of underutilization or idle time. It can even be more cost-efficient than provisioning an autoscaling group, due to more efficient bin-packing of the underlying machine resources.

This can be described as pay-as-you-go computing or bare-code as you are charged based solely upon the time and memory allocated to run your code; without associated fees for idle time.

Immediate cost benefits are related to the lack of operating costs, including: licenses, installation, dependencies, and personnel cost for maintenance, support, or patching. The lack of personnel cost is an advantage that applies broadly too cloud computing.

Elasticity VS Scalability

In addition, a Serverless architecture means that developers and operators do not need to spend time setting up and tuning autoscaling policies or systems; the cloud provider is responsible for scaling the capacity to the demand. As Google puts it: "from prototype to production to planet-scale."

As cloud native systems inherently scale down as well as up, these systems are known as elastic rather than scalable.

Small teams of developers are able to run code themselves without the dependence upon teams of infrastructure and support engineers; more developers are becoming DevOps skilled and distinctions between being a software developer or hardware engineer are blurring.

What's truly going on behind the scenes?

Now, it's a bit complicated but yet simple, bare with me!

It's (FaaS) Function as a Service, Serverless vendors offer compute runtimes, also known as Function as a Service (FaaS) platforms, which execute application logic but do not store data. Common languages supported by serverless runtimes are Java, Python and PHP. Generally, the functions run under isolation boundaries, such as, Linux containers.

Serverless Function code should have entirely stateless logic, so redundant instances will not cause inconsistencies for customers. Cloud hosting providers usually have many points-of-presence around the globe. This means that the servers in which an application runs are nearest to all possible end users. The cloud hosting provider will redundantly deploy a Serverless Function to data centers around the world, at the same time. This is good for a developer's customers because their client-side requests will be responded to with as little latency as possible. All of the networking logic is implemented by the cloud provider. Cloud hosting providers that offer Serverless Functions use industry standard best practices for automated code deployment. This means that there is no chance of human error breaking a service during deployment. It allows for fast shipment of new code, with little to no downtime for a web product.

What are these FaaS providers I speak of?

Well, truth is, there are many FaaS providers for many different use cases that each have their own individual quirks and personalities associated with them but here are a few:

AWS Lambda

AWS Lambda is a Serverless, event-driven compute service that lets you run code for virtually any type of application or backend service without provisioning or managing servers. You can trigger Lambda from over 200 AWS services and software as a service (SaaS) applications, and only pay for what you use.

Using Lambda functions is ideal in scenarios where on-demand compute is required e.g. provide compute for operations like file processing like file conversion.

Azure Functions

Azure Functions built by Microsoft Azure is a Serverless solution that allows you to write less code, maintain less infrastructure, and save on costs. Instead of worrying about deploying and maintaining servers, the cloud infrastructure provides all the up-to-date resources needed to keep your applications running.

Cloud Functions

Cloud Functions developed by Google Cloud Platform (GCP), Cloud Functions has a simple and intuitive developer experience. Just write your code and let Google Cloud handle the operational infrastructure. Develop faster by writing and running small code snippets that respond to events. Streamline challenging orchestration problems by connecting Google Cloud products to one another or third party services using events.

Conclusion

Identify what you are trying to accomplish and what is the given criteria that needs to be met. Answering these questions is the simplest way to distinguish between the different Function as a Service (FaaS) vendors to ultimately find the proper solution for your specific use case.

My beginners recommendation to learning Serverless computing is this crash course by FreeCodeCamp: Serverless Functions Course - Create a Serverless API

My Intermediate - Advanced recommendation would be this 7-hour course by A Cloud Guru called Building a Full-Stack Serverless Application on AWS

Lastly, Serverless is best learnt through doing, so pick a FaaS and work with one, for beginners I recommend AWS Lambda, you can write code using Java, Go, PowerShell, Node.js, C#, Python, and Ruby. It takes time to learn it especially if you are new to cloud and AWS but with a bit of practice, you'll be riding the Serverless bicycle easily.

Thanks for tuning in and have a great day!

Get up and running with Terraform (IaC) Tool

Jordan Tingling — Wed, 18 May 2022 20:08:37 +0000

What exactly is this amazing tool?

Infrastructure as code (IaC) tools allow you to manage infrastructure with configuration files rather than through a graphical user interface. IaC allows you to build, change, and manage your infrastructure in a safe, consistent, and repeatable way by defining resource configurations that you can version, reuse, and share.

Terraform is HashiCorp's infrastructure as code tool. It lets you define resources and infrastructure in human-readable, declarative configuration files, and manages your infrastructure's lifecycle. Using Terraform has several advantages over manually managing your infrastructure:

Terraform can manage infrastructure on multiple cloud platforms.
The human-readable configuration language helps you write infrastructure code quickly.
Terraform's state allows you to track resource changes throughout your deployments.
You can commit your configuration to version control to safely collaborate on infrastructure.

How exactly do I manage my Infrastructure?

Terraform plugins called providers let Terraform interact with cloud platforms and other services via their application programming interfaces (APIs). HashiCorp and the Terraform community have written over 1,000 providers to manage resources on Amazon Web Services (AWS), Azure, Google Cloud Platform (GCP), Kubernetes, Helm, GitHub, Splunk, and DataDog, just to name a few.

How do I deploy my Infrastructure?

Terraform's configuration language is declarative, meaning that it describes the desired end-state for your infrastructure, in contrast to procedural programming languages that require step-by-step instructions to perform tasks. Terraform providers automatically calculate dependencies between resources to create or destroy them in the correct order.

In order to deploy infrastructure with Terraform, you need to understand a few basic concepts:

Scope - Identify the infrastructure for your project.
Author - Write the configuration for your infrastructure.
Initialize - Install the plugins Terraform needs to manage the infrastructure.
Plan - Preview the changes Terraform needs to manage the infrastructure.
Apply - Make the planned changes.

Conclusion

Terraform also keeps track of your real infrastructure in a state file, which acts as a source of truth for your environment. Terraform uses the state file to determine the changes to make to your infrastructure so that it will match your configuration.

Terraform even has it's own cloud!

Terraform allows you to collaborate on your infrastructure with its remote state backends. When you use Terraform Cloud (free for up to five users), you can securely share your state with your teammates, provide a stable environment for Terraform to run in, and prevent race conditions when multiple people make configuration changes at once.

Keep learning Terraform and other Infrastructure as Code (IaC) tools!

To learn more about Infrastructure as Code, check out this blog post: What is Infrastructure as Code?

Additional Information:

Hashicorp Learn is a great place to learn Terraform for beginners - intermediate level. They also teach how to use Terraform with cloud providers (AWS / Azure / GCP) & tools like kubernetes, Docker, etc.

Hashicorp Learn

FreeCodeCamp also have a quick crash course on Terraform but more specifically, "Automate your AWS cloud infrastructure" using Terraform.

FreeCodeCamp - Terraform Course - Automate your AWS cloud infrastructure

Deepgram x DEV Hackathon Submission - VocalBridge - An AudioBook & Podcast Speech-to-Text application!

Jordan Tingling — Sat, 02 Apr 2022 22:51:44 +0000

Introduction

I'm a Cloud enthusiast (AWS primarily) and student at the University of London (BSc Computer Science). I'm new to Deepgram and their Speech-to-Text API based on deep learning and AI, however, I'm not new to app and website development. I have knowledge and experience designing and building web & mobile applications and integrating native & non-native API's into them. From concept/sketches/wireframes to UI/UX design and further into production or development.

I decided to participate in the "Innovative Ideas" category of the Deepgram Hackathon on DEV simply out of curiosity and innovation. I wanted to create an application that would solve a problem that I have, in a very simple manner. The problem is, there are times I want to listen to an AudioBook or Podcasts or even both but I don't have 2-3 or even 4+ hours to be listening and even if I did have that amount of time, my brain would be fried by the end of it and I probably wouldn't have retained much. I wanted to create a solution for this, what if I could use "keywords or/and phrases" as an input into an application? That is able to give me the most essential information relating to my given "keywords or/and phrases" in a small concise manner, maybe 2 or 3 paragraphs if I'm in a hurry or possibly a page or 2 if I have time. That was the simple thought process I had when creating "VocalBridge". I'm not sure of the small details of the "how" I could make this happen with Deepgram, that is why, this application is in the "Innovative Ideas" category of the Deepgram + Dev.to Hackathon.

My Deepgram Use-Case

—

This project was created as an application that would integrate with Deepgram. VocalBridge offers a huge range of AudioBooks & Podcasts to offer children and parents. I was inspired by the idea of reading bite-sized chunks of information on-the-go in a matter of a minute or two from an AudioBook and/or Podcast that is usually 1 or 2+ hours of audio content. There are solutions out there that can fulfil this task in a similar manner, however, VocalBridge is able to search and transcribe intelligently the most "important" phrases or lines of these audio sources and transcribe them in an orderly way that is not only pleasing to the eyes of the user but also sensible and intuitive just as if it was written that way in that specific order even though it was not. That is the "secret sauce" of the application that is VocalBridge, even though this is only a concept, I am sure that this application would be a life saver for persons that are on-the-go and simply want a brief synopsis of the actual content within the AudioBook and/or Podcast, not only the descriptive summary provided by the author or distributor/provider of the AudioBook and/or Podcast.

Dive into Details

—

VocalBridge is pretty much a simple idea that was created to solve a simple problem for so many individuals that are on-the-go and need that bite-sized chunk of information and don't have hours on end to listen to a full blown AudioBook and/or Podcast. This project is suitable for people of all races, ages and religions. It would be beneficial for persons 16-28 years old, that are usually going to school with assignments, an AudioBook or Podcast may contain crucial information for them which they can make good use of and individuals that are 20-45 years old that are usually working, have children or other responsibilities and would like to gain the information within an AudioBook or Podcast but don't have the hours required to listen to these audio sources.

Children would also benefit greatly from the services of VocalBridge. By reading kids AudioBooks and/or Podcasts, kids could gradually begin or continue learning and understanding words and phrases of songs or poems within these AudioBooks and/or Podcasts. VocalBridge's idea with the help of Deepgram, is made to be the transcription bridge from these various audio sources to text and provide an everyday solution for the issue of having to listen an entire AudioBook or Podcast to learn the true meaning within it. VocalBridge aims to reduce the time needed to accomplish this task into a matter of minutes for millions of persons regardless of their age, religion, and race.

Conclusion

—

Finally, VocalBridge was an extremely fun "Innovative Ideas" challenge mobile application project. I'm an AWS guy so if I was to actually build this mobile application, There definitely would be some type of incorporation with AWS within this mobile application. There would also be a web application built for users that prefer a laptop/desktop experience rather than a mobile experience. Lastly, VocalBridge was a treat to create, this application is indeed a prototype, but it was interesting to create a simple problem solver. Thank you Deepgram + Dev.to for the Hackathon!

Here is a link to the prototype of VocalBridge, please keep in mind that this is a "prototype", not a real working application. Enjoy!

https://cloud.protopie.io/p/73a7b2d6bb

Cloud Resume Challenge - My Journey

Jordan Tingling — Thu, 03 Mar 2022 17:53:00 +0000

Who Am I?

I'm a Cloud enthusiast (AWS primarily) and student at the University of London (BSc Computer Science). I do have experience in front-end and back-end engineering, however, this was a step in a new direction that allowed me to get my hands really cloudy with AWS.

My journey through learning AWS was surely an impulsive one, It began with ACG A Cloud Guru which I pay massive respect to for starting my journey into the cloud. I stumbled upon the Cloud Resume Challenge through (Youtube/Linkedin/Reddit) by Forest Brazeal (Cloud Architect, AWS Serverless Hero). Here is some information about the challenge here.

I am definitely late to the party, (the last date set by Forrest Brazeal on this challenge was 31-July-2020) due to my preparation for AWS certifications, however, I still wanted to give it a try. I would also like to thank Alex Eversmeyer, as I referred his blog and Github repos, whenever I needed assistance.

Let's Get To It!

AWS Certification

Being new to the world of AWS and cloud computing, I achieved the AWS Certified Practioner Certification in Sept 2021. I then went on to achieve the AWS Certified Solutions Architect Associate (Nov 2021), and AWS Certified Developer Associate (Dec 2021), currently, I am preparing for the AWS Certified Solution Architect Professional. Massive shoutout to Adrian Cantrill for his in-depth and hands-on courses and labs. ACG gave me the introduction to the cloud, however, Adrian pushed me even further into understanding AWS technologies at a deeper level.

Front-End (HTML/CSS/JS)

I tried to keep it as minimalistic as possible. I have front-end experience, however, I wanted to focus more on the technologies which make up the bulk of this challenge and not tinkering with CSS all day long. The HTML page would also be linked to a JS file that contains the JavaScript snippet which will update and fetch the visitor count from the "back end" (DynamoDB, Lambda, API Gateway).

Static S3 Website

Based on the knowledge I acquired during the preparation of AWS certifications, hosting a static website on S3 and using CloudFront for content distribution was easy (CloudFront even provides you with an automatic "CloudFront SSL Certification". I purchased a domain name using AWS Route 53 and set up my hosted zone and configured it to use the CloudFront distribution. Also, I made use of AWS Certification Manager(ACM) to procure my personal SSL certificate for the site.

Here is a brief overview of the architecture, Thanks Luis Nuñez for the diagram.

Back-End

The backend infrastructure and logic were needed to update and retrieve the "visitor count" from a database table (DynamoDB table) that is needed for the front-end to display this count on the website. The backend involved the use of AWS resources like API Gateway, Lambda, and DynamoDB.

DynamoDB: DynamoDB is AWS's fast and flexible NoSQL Database service offering for any scale. I created a simple DynamoDB table with one item to store and update the visitor count. A snipped of Python code comes in handy here. The numeric value increments each time you call the DynamoDB table. This operation is implemented in the Lambda function (more details below).
Lambda: AWS Lambda is a compute service that lets you run code without provisioning or managing servers. I created a python based Lambda function, which queries the DynamoDB table and updates the visitor count item. I utilized an API call which is made to an API gateway to increment the numeric value (add a visitor counter).
API Gateway: Amazon API Gateway provides the option to create and manage APIs to back-end systems running on Amazon EC2, AWS Lambda, or any publicly addressable web service. In my case, the API Gateway exposes a REST API Endpoint, which will be called by a Javascript snippet embedded in the front-end HTML page, on every page visit/refresh - to update and fetch the visitor count from the DynamoDB table, through the Lambda function. Enabling CORS (Cross-Origin Resource Sharing) on the API Gateway resource is mandatory to fetch the response back when it is called.

Summary

The concept is quite simple: Each time the website is requested, an API call is made to an API gateway, which in turn maps to a lambda function. This lambda function does nothing else than increment a field in a DynamoDB table. The new counter is returned and displayed on the web page.

Back-End (Infrastructure as Code)

Even though the backend is relatively simple and can be assembled in a few minutes in the AWS Console, it's still not the most convenient way, especially if you need to update or delete something. Fortunately, AWS has our back and offers the ability to provision our cloud infrastructure in a number of ways. In this case, we use AWS Serverless Application Model (SAM), an Infrastructure as Code (IaC) solution that allows us to define and build our Serverless application using a single YAML template. Among other things, this allows us to keep and update our infrastructure together with our codebase and, most importantly, to create an application infrastructure that can be reproduced over and over again.

Here is a brief overview of the architecture, Thanks AWS Community Builders for the diagram.

My architecture is slightly different in this case, however, this is a general overlook of similar architecture.

Front-End - CI/CD

Even though AWS SAM takes some of the work off my shoulders, currently updating the website still means some manual effort. AWS SAM has to be installed locally, then, the application has to be built and then deployed. All this costs time and should therefore be automated. For front-end CI/CD, I used GitHub Actions to configure AWS credentials, deploy the changes to the S3 bucket (which stores HTML/CSS/Js/images content), and then invalidate the CloudFront distribution. This deployment workflow can then be configured to execute on each push to the master branch, updating the entire application stack without any additional intervention by me.

Back-End - CI/CD

A separate GitHub repo was created to store the back-end code, which included the Lambda function, SAM Template, and Python tests. Corresponding GitHub action is created to configure AWS credentials, run python tests, SAM builds and SAM deploy commands. AWS credentials are configured to securely store environment variables such as AWS Login Keys. These credentials are retrieved from secrets defined in the GitHub repository. After that, the same steps are performed that would also be executed locally on the developer's PC: build the application with npm and push the folder to S3 via the AWS CLI. Afterward, the CloudFront cache is invalidated so that pushed changes are displayed immediately.

Conclusion

🏅 That's it! The challenge was great, it covers many AWS Services and how to use them together along with programming languages (Js/Python). Overall, it was a great experience, challenging and frustrating at times, especially regarding AWS SAM but it was worth it.

Big shoutout to: AWS Community Builders for their extremely helpful resources.

Here is the final version of my resume:
Jordan_Tingling_Resume