DEV Community: Birnadin Erick

Errors in Go - Beginner level

Birnadin Erick — Thu, 16 Nov 2023 11:16:04 +0000

TLDR;

This post delves into beginner-level error handling in Go. I will demonstrate Go's straightforward approach using the error value and emphasize the simplicity of handling errors with if statements. Custom error types, with examples, are introduced for enhanced debugging. This concludes with a teaser for upcoming topics like error wrapping and Is/As constructs as well.

Basics

In Go, errors are handled in an anachronistic way. Just like rust and C(go's predecessor) errors are returned from a function to a caller; this value is separate (error Value) then the intended type when the execution is succeeded. The following code example illustrates this fact...

func TryDivide(numerator, denominator int) (int, error) {
    if denominator == 0 {
        return 0, error.New("cannot divide by 0") // an error is returned
    }
    return numerator / denominator, nil // make error nil
}

In the above code following are to be derived:-

return type is a tuple with the last record being an error
when returning error, other records should be set to their zero values
error initialized by error.New() function
error messages should start with lowercase
not to end with a newline or punctuation

Handling

Error handling in Go does not have any special constructs dedicated to it.

Check with if and proceed

res, err = TryDivide(10,3)
if err != nil {
    // logic to handle the error
    // usually program exits or returns error of its own.
}

// move on with business logic

The idiomatic way of handling an error:

inside if is what handles the error
outside if is continued business logic

By the above pattern, a reader can follow along the code base rather than having to switch between the branches. The latter is evident in languages that have a construct of try/catch blocks; this will introduce a new branch the code could develop often leading to complex control flow.

Custom Errors

often we may want to embed more information into error for later usage for debugging purposes. for example, we can include the parameters passed in or the environmental values configured at the time of the error etc;

as with other places, go error is just an interface with one requirement--

type error interface {
    Error() string
}

error is often called this .Error() function which returns a string(message or anything). So to create a custom error type for web-server handlers or so we can embed the status code as well...

type ServerErr struct {
    code int
}

func (se ServerErr) Error() string {
    return fmt.Sprintf("error code was: %i", se.code)
}

Conclusion

this was a very quick rundown. There are other concepts to cover like:

wrapping errors
Is/As constructs
sentinel errors

But they are not necessary for basic usage; I will cover them later. If you want it already, let me know in the replies. I will post it immediately once I write it. Follow for more web development-related concepts.

Till then it's meTheBE, signing off.

RESTful Client Server Architecture, that is fading away, and pitfalls for beginners.

Birnadin Erick — Thu, 16 Nov 2023 11:05:46 +0000

Hold on tight because, in this blog series, we're throwing Roy Fielding's REST into the ring with the flashy, beginner-friendly moves of modern frameworks. It's like the ultimate face-off of web development philosophies. Oh, and did we mention we'll be throwing in some roasts too? Get ready for a wild ride where we break down the classics, roast the trends, and laugh along the way. It's the Fielding vs. Frameworks showdown, and things are about to get spicy! 🔥💻

I won't be talking about Web3, I am here to indicate the
direction of current frameworks violates the original REST!

Source: Fielding Dissertation: CHAPTER 5: Representational State Transfer (REST)

Architecture

The architecture of RESTful sites should be client-server.

Described in Fielding Dissertation: CHAPTER 3: Network-
based Architectural Styles

Promotes Separation of Concerns

By isolating UI from data storage concerns, portability is improved; thus, scalability. This supports the Internet scale with a robust backbone.

From recent Next.js announcements and such, these concepts are fading away. These raise issues when trying to scale out the application in a cost-effective way. Such curtains to the foundation will not be beneficial for beginners, who are the majority going for React-based apps.

Here, the button is UI and sent to the client, and the closure would be converted into an API endpoint or something (I don't bother to check further). If a beginner glances over this and learns from this, then that person might never see the light of actions happening behind the scenes. The following are cloaked by bringing UI and data storage together:

Call to an endpoint
Session management to identify the user issuing the request
The request is which HTTP verb
SQL DBMS connections
DBMS connection pools
Binding variables to SQL to prevent XSS

All the above are pretty serious points for a beginner to understand the systems; and later debug it. Let me explain my concerns on this Next.js stupid black-box feature.

Call to an Endpoint

I don't know for sure, but I guess that this will be converted to an API endpoint then an AJAX (or something) request will be made from the browser. If someone is a beginner and doesn't know this, then this is a blind spot!

Logs to such endpoints will be cryptic for them. Might think buttons can make HTTP calls; worse they wouldn't have an idea about HTTP as well.

Session Management

How do you know which user to bookmark this? Conceptually this demo feels wrong. A table with just slugs? No association with the user or actor? No foreign keys? Realistically there should be an association with the actor and action. But how do you define the relationship? Which method are you using? The choices are not clear!

Is it JWT? Basic Auth? OAuth? Session Ids? I will assume a session with cookies and a URL as a fallback.

This piece of code, which is in the context of a session, is not obvious. Too much abstraction. A beginner will miss this and might be confused altogether.

HTTP Verb

Which HTTP verb request is used here? INSERT corresponds to POST? Isn't that a leaky abstraction? If I change the SQL query then the API structure changes; documentation is not in sync, and older clients are failing since I changed

INSERT INTO tbl (col0) VALUES (arg0);

...to update the tbl.col0 instead of adding new records. Now endpoint is PATCH, but older builds are POST? Wait, is it PUT now? Yup, how do you identify whether the request is PATCH or PUT for better documentation?

Worst-case scenario, beginners of web dev might not even know, the distinctions, definitions, and pros-n-cons of each. They are blindly following the hype without realizing the system, and without learning the craftsmanship.

To their credit, this is OK for a seasoned player who knows what they are doing. But Next.js is almost marketed as beginner-friendly, quickly becoming a full-stack developer and such.

SQL DBMS

I didn't know anything about setup. But this single screenshot seems to indicate, the hustle to pass around SQL connections/pools is no more. This is good, abstracted away. But for a framework targeting beginners should let them cook; at least for a while.

I started with PHP. fetch_row() and execute() taught me how stuff works; then switching to Django seems like a knife in butter. Everything clicked and felt relief. Imagine doing this and then when you get famous and a client with a low budget needs a PHP site and then you learn you can't do these easily in PHP and you have to manually do that! Using ORMs in PHP would be the last resort, often harder to construct complex queries than so. What are you gonna do? Call Ghostbusters!

Same case as above. (Thank God I started with C, without realizing it was such an old. Why C? I found a book in the library and followed that out of hype, no guidance whatsoever)

XSS and Binding

Say you are a beginner and try to run the above code. Unless documentation specifies it, I doubt you ever heard of XSS. It is real! I think Next.js framework devs would be wise enough to make that slug bind to the query instead of replacing/concatenating the slug value.

Say you didn't know that and now have to develop a FastAPI application. Unless you are using an ORM, if you sort to custom SQL cursors since the project was so small and used f-string to construct the queries, may God have mercy on you.

Conclusion

Please don't take this as a hate post on Next.js rather than a handful of concerns on the direction of Next.js's development from someone who loved it when it was rational and following UNIX philosophy...

Do one thing and do it well

Next.js was a server framework to get React on SSR (some sort), but now it takes on data storage as well it seems, image optimizations and delivery, font and such asset management then also caching and revalidation; along with bundling with turbopack.

If you want to dive into this React business, start with Remix, they are better IMO; then come back to Next.js or use HTMX!

Advanced Python: The lambda

Birnadin Erick — Sun, 04 Jun 2023 23:13:01 +0000

Ever had to write this…

def func(n):
  # only allow `l` no of characters in the `n` string
  return n[:l+1]

parsed_n_s = map(seq, func)

When you could have done this…

# only allow `l` no of characters in the `n` string
parsed_n_s = map(seq, lambda n: n[:l+1]) # is this more readable?

Read along to learn WTF is this lambda anyway.

2 kinds of Python functions

Python supports two kinds of functions, no, I am not talking about a standalone function and a method of a class. I meant named and anonymous functions. If you have been doing it the first way, you know what named functions are. For the record,

def func(param):
  # body
  pass

And the anonymous goes like

lambda param: pass #body

Anonymous means you don’t get to call it by a name. It’s just temporary, a quickie. But you can go out of your way and can do this though.

func = lambda param: pass # body

This style might help you if the function body is so simple and writing the whole def ... shenanigan is a waste of time, space, and effort.

Quickie, not Shorty

Even though lambda seems simple, it is so powerful enough to execute somewhat complex logic. Not flexible as the named function though 🤷‍♂️. How complex you asked?

This 👇

extract from another post

Can become, this 👇

another extract from the same post

I wouldn’t recommend this kind of one-liner in a prolonged codebase, but for quick scripts it does the job pretty well, saving some typing time. For context, please read my post on Python Comprehension.

Advanced Python: Comprehensions

Powerful one-liners for generators in python3

medium.com

lambda functions always return something; hence lambda never gets void as its return type, and the last execution will implicitly return the result.

Applications

Before applying the lambda let’s just summarize: -

defines an anonymous function,
implicitly (no need for return lexeme) returns the result of the last logic,
cannot span to multiple lines (if I am wrong, let me know in the comments or dm me).

I guess that’s it. Without ado let’s get started

1. along with map

I extensively use lambda in the map if the logic is simple or can be included in one line. Say, you have a list of strings of varying length, but you need to cut everything down to 120 words (maybe you are doing a Twitter clone with tkinder and python, I don't know 🤷‍♂️)

tweets = [...] # the initial tweets
tweets = map(lambda t: t[:121], tweets)

If it weren’t for *lambda*s, then that one-liner would be…

tweets = [...] # the initial tweets
parsed_tweets = []
for t in tweets:
  parsed_tweets.append(t[:121])
# now parsed_tweets is, parsed 😁

Which one do you prefer, I prefer the first one as it is more precise and requires less mental effort to comprehend.

2. along with filter

Just like map, lambda is so useful when using filter. E.g., If you are to generate odd number series from 1 to n, in front of your crush, then with lambda you could just,

gen_odd = lambda n: [i for i in filter(lambda i: i%2, range(1,n+1)]

without lambda, you would be mopping the floor like…

def gen_odd(n):
  result = []
  for i in range(1,n+1):
    if i % 2 != 0:
      result.append(i)
  return result

It is assumed that your crush is either a noob in python or a JavaScript developer.

Of course, You could have done this,

result = [i for i in range(1, n+1, 2)]

But where’s fun in that 😜, when she’s watching. Be careful not to mess up anything or you will be this meme.

from imgflip.com

3. saving some characters to type

Instead of spanning 2 lines of code to square a number or raise a number to power of something else, you can do it in one line with few whitespaces (assuming you can’t use pow std utility)

def pow_1(x,n):
  return x ** n

pow_2 = lambda x,n: x ** n

You can see that pow_2 is tidy and just to the point without any clutter or boilerplate code.

4. in re.sub()

If you need to substitute some group of characters adhering to pattern iterating over more than 1 specimen, then regex has you covered. I especially used this to create my Template Engine.

How to build a simple template engine with Python and regex

E.g.,

import re
specimen = "hello world"
pattern = r'\w+'
final_str = re.sub(pattern, 'WORLD', specimen)

Wait, I just want to replace the last part, not just world to WORLD but any last word should be Upper! Well, regex’s group and lambda are to the rescue…

import re
pattern = r'(\w+)\s(\w+)'
final_str = re.sub(pattern, lambda m: m.group(1) + ' ,' + m.group(2).upper(), specimen)

Of course, many ways to do this, some of which might be better, but I couldn’t think of any as of writing this. If you think there are other ways with or without lambda but with lesser time complexity, please point them out in the comments, If not give this post a clap, wouldn’t cost you any 😍 and follow me 😘.

Epilogue

Alright, that’s all I got for now, if I ever come across anything new about lambda I will put it in the comments or just update the post itself, so make sure you bookmark it or something. If you ever come across something awesome as well, please comment. Wouldn’t hurt or cost you to share the knowledge 🎊

If you are intrigued and interested, go ahead and follow me on Medium or on Twitter.

Till I see you next time, it’s me the BE, signing off 👋.

How to built a simple template engine with Python and regex

Birnadin Erick — Sun, 04 Jun 2023 23:08:11 +0000

Prologue

As I mentioned previously I want to create a static content creation system. The first step is A Template Engine. Rather than building a fully featured template engine, I am planning on what is just needed, in this major iteration.

I have also saved some bonus features for later major iterations 🎊.

With that being said, this major iteration(namely v1.0.0) will have 2 basic features:

Including external templates into another, OR Inheritance, I guess 🤔
Looping over a dataset to produce multiple pages

Before anything, we should decide on the syntax. The generic one I have decided looks like...

{ macro_name macro_parameter }

Without further ado, let's go 🏃‍♀️

1. Including external templates into another

For this, the syntax would look like this to embed another page called index.html into base.html

base.html

<html>
<head>...</head>
<body>
    <!-- some generic content -->
    { include content.main }
</body>
</html>

index.html
```
<h1>Welcome to SPC</h1>
```

So what I want to do is to read through base.html and replace the line if {} is encountered. We could do this in many different ways, but an easy one is the regex way.

regex stands for Regular Expression

The usage of regex with python is much simple than other languages make it seem. If you want me to do a swing-by regex with python, please let me know in the comments.

So to substitute the template we would do something like

import re # import the standard regex library

pattern = r'{\s?\w+\s(\w+.\w+)\s?}' # regex pattern to search for
specimen = """
<html>
    <head>...</head>
    <body>
        <!-- some generic content -->
        { include content.main }
    </body>
</html>
"""
replace = "<h1>Welcome to SPC</h1>"

parsed_str = re.sub(pattern, replace, specimen) # using .sub() from library

Now if we write parsed_str to a file, will be the page we intended for. Now, let's encapsulate it into a function for modularity and to be DRY. Thus, the function would be

def eval_include(specimen, replacement):
    global pattern
    return re.sub(pattern, replacement, specimen)

If you are disgusted by the global keyword, just so you know, I am coming from assembly language and Cheat-Engine 😜, I am pretty comfortable with it.

Now, an end user might use the library like

from os.path import realpath
from mathew.macros import eval_include

base = ""
with open(realpath("templates/base.html"), "r") as b:
    base = b.read()

index_template = ""
with open(realpath("templates/index.html"), "r") as i:
    index_template = i.read()

with open(realpath("out/index.html"), "w") as i:
    i.write(
        eval_include(base, index) # do the templating magic 🧙‍♂️
    )

Parsed page can be found in the out/ dir. File discovery and all other stuff will be automated later. For now, let's just focus on one thing.

2. Looping over a dataset to produce multiple pages

Let's say, we have a list of article titles to display on the homepage of the blog page. E.g.

pubslist.html

<section>
    <h2>Patrician Publications</h2>
    { include pubsdetail.html }
</section>

pubslistitem.html

<article>
        <h4>{ eval pubs.title}</h4>
        <span>{eval pubs.cat }</span>
        <p>{ eval pubs.sum }</p>
</article>

and the dataset

{"pubs": [
{"title": "Some 404 content", "cat": "kavik", "sum": "Summary 501"},
{"title": "Some 403 content", "cat": "eric", "sum": "Summary 502"},
{"title": "Some 402 content", "cat": "beric", "sum": "Summary 503"},
{"title": "Some 401 content", "cat": "manuk", "sum": "Summary 504"},
]}

The dataset can be mapped to python's dict without any logic. The difference between embedding another template from evaluating a variable and creating many pages by just replacing the data in the template appropriately and embedding the end-string to the destination template. Let's do it, shall we?

For evaluating the variable, we could use the Groups feature in the regex. That's what the () around the \w+.\w+ in the pattern for. We can easily access the matched string slice by the .group() method on the match object returned by re lib-functions.

str_1 = "Hello 123"
pattern = r'\w+\s(\d+)'
digits = re.finditer(patter, str) # returns aggregation of `match` objects

for digit in digits:
    print(digit.group(1)) # 123

Notice we are calling for 1, not 0. Nothing that the lib is 1-index, it is 0-indexed but 0^th index is the entire str, "Hello 123"

Remember the .sub() method, its second parameter accepts either str or a callable. This callable will get a match object as an argument for each matched pattern validates. So we can produce dynamic replacements based on each match like...

# retriving the key from template string
key = m.group(1) # == pubs.title
key = key.split(".") # == ["pubs", "title"]
key = key[1] # == "title"

# evaluating the variable with i^th record from dataset
re.sub(
       pattern, # the pattern
       lambda m: dataset["pubs"][i][key]
)

If lambda is mysterious for you, it is a way to define an anonymous or inline function in python

Defining functions for lib API be

# map each datumset
def __eval_map(string, data):
    global pattern
    return re.sub(
        pattern, lambda m: data[m.group(1).split(".")[1]], string
    )

# parse the batch of dataset
def parse_template(template, data):
    return [
            __eval_map(template, datum)
            for datum in data
        ]

parse_template returns aggregated results using list comprehension syntax, if you are unfamiliar with the syntax let me know in the comment

So accessing the key to evaluate is just as breezy as...

from os.path import realpath
from mathew.macros import parse_template, eval_include

specimen = """
<article>
    <h4>{ eval pubs.title}</h4>
    <span>{eval pubs.cat }</span>
    <p>{ eval pubs.sum }</p>
</article>
"""
dataset = {
       "pubs": [
        {"title": "Some 404 content", "cat": "kavik", "sum": "Summary 501"},
        {"title": "Some 403 content", "cat": "eric", "sum": "Summary 502"},
        {"title": "Some 402 content", "cat": "beric", "sum": "Summary 503"},
        {"title": "Some 401 content", "cat": "manuk", "sum": "Summary 504"},
        ],
    }

# parse each `<article>` tag for each list item
parsed_str = parse_template(specimen, dataset["pubs"])

# join the `<article>` tag-group
pubs_list_items = "".join(parsed_str)

pubs_list_template = ""
with open(realpath("templates/pubslist.html"), "r") as p:
    pubs_list_template = p.read()

# parse the `pubs_list` itself
parsed_list = eval_include(pubs_list_template, pubs_list_items) 

# write the final file with base
with open(realpath("out/pubs.html"), "w") as i:
    i.write(
        eval_include(base, parsed_list)
    )

Final pubslist.html will be in out/ directory.

Done?

Not quite so. Did you notice the fact, that we still have to read the template string manually, have the data populate in a specific format and the parsing of the template is still manual.

These are for later. For now, we have a simple working template engine that does the job I intended it for. I am happy with it.

Another thing, keen eyes might have noticed is the macro_name in the template does nothing, in fact, if you swap include with eval or anything, as long as the latter part is valid, the script does its job. This is a bad design but the worst part is our eval_include allows only one template. Gotta fix that!

Epilogue

I guess I don't have anything further, so I will just sign off, this is BE signing off.

Cover by Suzy Hazelwood