DEV Community: dev0928

Architectural Patterns

dev0928 — Tue, 10 May 2022 22:45:15 +0000

Software architecture patterns focus on how applications can be organized at a higher level. They provide best practice solutions for some of the common problems such as ease of maintenance, deployability and scalability. Solutions written using common architectural patterns are easier to understand as they follow a widely recognized pattern.

In this article, let’s discuss some of the popular architectural patterns. It is worth noting that systems don’t strictly follow one of the patterns, often they follow a combination of architectural patterns based on application’s needs.

Monolithic Architecture

In a monolithic architecture, the entire application is a single executable unit often consisting of hundreds of thousands of lines of code. Well structured monoliths often follow a layered approach, namely database layer that interacts with the application’s database, business logic layer holding business logic of the application, and an interface or controller layer that is the main interface to application’s UI. Usually monolith applications start with a small set of functionality and often tend to grow over time as new features get added resulting in a single complex system that is harder to maintain.

Monoliths are

Easier to get started with few resources
Result in complex systems - often times it is hard for one person to understand the functionally of the entire system
Usually entire application’s code base is part of one repository, this results in tight-coupled harder to maintain systems

It is often less expensive to replace monoliths with more modular systems than maintaining monoliths over time. Many large enterprise systems once started as monoliths have successfully replaced their solution to more modular subsystems.

N-tier Architecture

In N-tier architecture, applications are split into multiple tiers such as data tier, business logic tier and presentation tier. These tiers can be deployed in the same server or can be deployed individually. Often the application’s tiers are split based on technical boundaries. Data flows from one tier to the next without skipping a tier. Hence, some level of coordination is needed during deployment.

As the individual tiers can be independently scaled, N-tier architecture is an improvement over monolith architecture.

Service-oriented Architecture

Applications built with service-oriented architecture comprise of many loosely coupled services. Services are often broken by business functions. They have standard data contracts to communicate among services and use an enterprise service bus for inter-service communication.

Applications following service-oriented architecture are loosely coupled which is a great improvement over monolith and N-tier architectures. Since the coordination of data flow happens through the enterprise service bus, all services depend on the enterprise service bus. This could become source of the application’s unavailability when there are failures in the enterprise service bus.

Message-based Architecture

Messaging-based architectures in general are the ones that communicate with each other using shared messaging infrastructure. Messages are small pieces of self-contained information sent from one system to another often in a JSON format. There could be two types of messaging - queue based and publish / subscribe. Queue-based systems send information to one target audience. Publish / subscribe model broadcast information as topics and there could be multiple subscribers for a given topic.

Systems built using event-driven architecture are loosely coupled but often tend to be more complex as it is harder to fully get the big picture of various systems through which message (data) flows.

Microservices Architecture

In microservices architecture, a large system is made of small individual subsystems that work as peers to solve an application's problem. These individual services are self-contained and are backed by a small team that solely owns and manages the service. Microservices contain a few hundred lines of code resulting in easy to understand, test and deploy systems. Services could either communicate directly with each other or follow a message-based approach for inter-service communication.

Reactive Architecture

Microservices built using reactive systems tend to follow reactive architecture. Systems built as reactive architecture are more flexible, loosely-coupled and individually scalable.

Reactive Systems are

responsive - they respond in a timely manner
resilient - the system stays responsive in the face of failure
elastic - work well in varying workloads
message-driven - follow asynchronous messaging there by enabling non-blocking communication among services.

Serverless Architecture

A popular flavor of serverless architecture is a Function as a Service (FaaS) architecture. A function as a service architecture consists of multiple pieces of code called functions, which when invoked run a small container.

Advantages:

Serverless architectures can easily scale when there is an increased demand
As infrastructure of serverless applications is maintained by the cloud provider, there is no server maintenance overhead
As there is no server provisioning overhead with this setup, it is very easy to experiment with new ideas

Disadvantages:

As execution environment may get provisioned for every function invocation, functions deployed using serverless architecture cannot maintain state
Cloud providers often have memory / execution duration limits for functions created in a serverless-way

What are type hints in Python?

dev0928 — Sat, 24 Apr 2021 16:07:20 +0000

Python is a dynamically typed language. This means we don’t need to explicitly specify the type of a variable while declaring it. Python runtime engine infers variables' data type based on the value assigned to them. Here are few examples:

greeting = ‘hello’
print(type(greeting))   # <class 'str'>
count = 10
print(type(count))       # <class 'int'>

Even though the above way of declaration makes the code more concise, it is prone to type errors if the application being developed has a large number of modules and classes.

What are type hints?

Typing module introduced in Python 3.5 supports declaration of type hints to variables and function return types. Although Python runtime does not enforce variable and function return type annotations, these type hints can be used by Integrated Development Environments (IDEs) and type checkers to enforce static types. Thereby reducing bugs early during the development process.

Examples

from typing import List, Optional

def sum_nunbers(num1: int, num2: int) -> int:
    return num1 + num2

def get_square_list(max_num: int) -> List[int]:
    return [n * n for n in range(max_num)]

# An argument could be explicitly marked optional using below type hint 
def create_greeting(name: Optional[str] = 'World') -> str:
    return f"Hello, {name}"

print(sum_nunbers(10, 20))  # 30
print(get_square_list(5))   # [0, 1, 4, 9, 16]
print(create_greeting('Joe')) # Hello, Joe
print(create_greeting()) # Hello, World

Benefits of type hints

Type hints serve as a great documentation in larger applications
These type declarations could help uncover some of the type errors with the help of IDEs and type checkers

Further Learning

Although, type hints may be overkill for small experimental Python modules, they would be much more useful in a larger application. I think type hints if used consistently would help promote clean code that is easier to understand. To learn more visit - https://docs.python.org/3/library/typing.html

Intro to web app using AWS Serverless Architecture

dev0928 — Sat, 17 Apr 2021 13:54:26 +0000

Serverless architecture comprises a group of technologies working together as a single unit to deliver a solution. In this write-up, let’s review the involved technologies along with their high level purpose to build a web application.

Backend

Backend is a stand-alone service comprising three main components - Data store, Lambda functions used as a compute service and API Gateway acting as a main backend interface.

Data Store / Database

Aurora Serverless (PostgreSQL) is one of the options. There are few other serverless database options available to choose from. Data store choice purely depends on the type of data stored within the application.

Lambda Functions

Lambda functions with Python could be used on the backend. AWS Lambda supports many other options such as Node.js, Java, .NET Core, PHP.

API Gateway

API Gateway serves as a gatekeeper to the backend service. API endpoints can be secured and served through the API Gateway. API Gateway leverages lambda functions to perform necessary data processing to serve requests made to the API endpoint. Frontend applications or any other service requiring data can call these API endpoints with required security token to obtain necessary data.

Frontend

Frontend framework such as Angular, Vue, React or any other framework could be used to build the frontend website. During deployment, front-end code is built and deployed to AWS CloudFront CDN and served to the end users’ browsers upon request.

Security

AWS Cognito is an Amazon authentication and authorization service. This service also has support for SAML / OAuth2 / Open ID authentication through major Identify providers such as Facebook, Google, Okta.

Supporting Services

Besides above mentioned core services, there are many other supporting services involved in the serverless application architecture. Let’s review the purpose of these supporting services.

Serverless Framework

Serverless Framework helps develop and deploy serverless applications along with the required infrastructure resources they require. It's a CLI that offers structure, automation and best practices out-of-the-box and helps build sophisticated, event-driven, serverless architecture applications. Framework itself is built with Node.js but it can support multiple languages (Node.js, Python, Java, and more). This framework is cloud-agnostic meaning one can use this framework to develop serverless applications for any cloud provider.

AWS Serverless Application Model is an alternative option to serverless framework but it is specific to AWS.

AWS CloudFormation

AWS CloudFormation gives an easy way to model a collection of related AWS resources, provision them quickly and consistently across different environments, and manage them throughout their life cycles, by treating infrastructure as code. Serverless framework’s configuration files describe all of the services that need to be provisioned for a given application.

AWS S3

Simple Storage Service(S3) can be used as an intermediate storage for transferring and processing data from external systems. S3 can also be used for storing artifacts during the build and deployment process.

IAM

Identity and Access Management Service is one of the important services in this solution. This service is mainly used for providing granular access permissions among various services used within the AWS serverless environment.

Route 53

This service is used for domain registration so deployed applications could be accessed using a user-friendly URL.

AWS CloudWatch

AWS CloudWatch is a logging service used by other services to log messages within the serverless solution. Messages logged in the service can be used for setting up alerts in case there are errors/issues within the application.

Source Control

AWS CodeCommit is AWS provided solution for source control. Other third party source control solutions such as Github can also be used for source code management.

Code Pipeline

This AWS solution enables automation of continuous build and deployment of applications.

Amazon SNS

Simple Notification Service used for event messaging. Events could be notified to multiple interested systems enabling microservices / distributed processing.

Amazon SQS

Simple Queue Service is a messaging service used for processing events sequentially. This service can scale well and also has facilities for guaranteed delivery of sequenced messages.

AWS Systems Manager

Systems Manager Parameter Store is used for application’s configuration and secrets management.

VPC

All of the services configured for the serverless solution would be deployed within the application’s secure Virtual Private Cloud environment. VPC should be configured properly to avoid security holes.

Benefits

Here are some of the benefits of using serverless architecture:

This architecture scales well from few users to thousands of concurrent users.
As there are no dedicated hardware resources provisioned as part of this solution, there is no infrastructure cost around server maintenance and upgrades.
Also, the services involved in this solution are charged based on usage. This solution could be cost effective if configured properly.

Further Learning

https://aws.amazon.com/getting-started/deep-dive-serverless/
https://www.serverless.com/learn/

What are Data Classes in Python?

dev0928 — Mon, 12 Apr 2021 00:59:33 +0000

Data classes is a new feature introduced in Python 3.7. This feature aims to reduce boilerplate code sucs as __init__() and __eq()__ methods in user-defined Python classes. By using the dataclasses module’s decorators and functions, one can create concise Python classes. Let’s review the use of the data classes feature with an example.

Employee class could be declared concisely like shown below with the data classes decorator.

from dataclasses import dataclass, field

@dataclass
class Employee:
    id: int
    first_name: str
    last_name: str
    email: str
    base_pay: float
    tax_rate: float = field(default=0.01, init=False)
    hobbies: list = field(default_factory=list())

    def calculate_pay(self):
        net_pay = self.base_pay - (self.base_pay * self.tax_rate)
        return net_pay


emp1 = Employee(1, 'John', 'Doe', 'john.doe@example.com', 10000, ['Fishing', 'Soccer'])
print(emp1)    #Employee(id=1, first_name='John', last_name='Doe', email='john.doe@example.com', base_pay=10000, tax_rate=0.01, hobbies=['Fishing', 'Soccer']) 
print(emp1.calculate_pay())  #9900.0

@dataclass decorator above generates init, repr and eq methods by default. @dataclass generator without any parameters like declared above is equivalent to the below declaration:

@dataclass(init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False)

If order parameter is set to true, it will generate boilerplate methods lt, gt, le, and ge. Also, true value supplied to the unsafe_hash parameter would generate hash method.
Dataclasses use the typing module to define the data type of the declared class fields. However, if one wishes to not specify the field data types, they can use typing.Any for all of their fields in the class.
By default, all fields of the class are included in the generated methods. But this can be customizable using field declaration. For example, tax_rate field in the example is excluded from the init method.

tax_rate: float = field(default=0.01, init=False)

Also, we can use the default_factory parameter to initialize complex data types such as list.
Dataclasses module has several convenience functions. For example, dataclasses.fields function provides a list of fields in the form of tuple. Also, dataclasses.asdict returns a dictionary representation of the supplied object.

Dataclasses is one of the powerful features introduced in the recent versions of Python. Here is the link for learning more about it's capabilities so you can start using this feature in your projects.

Data Modeling Tool

dev0928 — Fri, 22 Jan 2021 13:37:31 +0000

Recently, I was looking for tools to quickly come up with an ERD (Entity-Relationship Diagram) for one of the client engagements. I wanted it to be something simple but aesthetically pleasing as it was an early stage of the project. I came across an online tool called dbdiagram.io. This tool helped in coming up with a nice pictorial representation of the data model relatively quickly.

Features supported by the tool:

Primary key representation
Foreign key representation along with one-to-one, one-to-many, many-to-one relationships
Support for representing fixed number of values a column can hold through Enum tables
Support for default values and unique column representation.
Ability to export created data models into PNG or PDF formats. Also, one can export SQL of the data model for PostgreSQL, SQL Server, and MySQL (account sign-up required to utilize these features)
Ability to import SQL to generate data model

How does it work?

Visit dbdiagram.io and come up with a desired data model structure like below. This tool generates data model as soon the entered structure is valid.

// Creating tables
Table department as d {
  department_id int [pk, increment] // auto-increment
  department_name varchar [not null, unique]
  created_at datetime [default: `now()`]
}

// Enum for 'employee' table below
Enum employee_status {
  active
  retired
  alumini [note: 'moved on to other career prospects'] // add column note
}

Table employee as e {
  employee_id int [pk, increment] // auto-increment
  employee_name varchar
  department_id int [ref: > d.department_id]
  status employee_status
  created_at datetime [default: `now()`]
}

Table employee_sales as es {
  employee_id int [ref: > e.employee_id] 
  sales_date datetime 
  sales_amount float
  Indexes {
    (employee_id, sales_date) [pk]
  }
 }

Example output is shown below

Getting to know "Succinctly" book series

dev0928 — Thu, 10 Sep 2020 10:03:15 +0000

I recently came across Succinctly book series by Syncfusion, a company that offers enterprise ready library of components and framework solutions. As a free product, Syncfusion also offers a wide range of ebooks on a variety of topics.

There are about 170+ ebooks on a wide range of topics like web development, programming languages, operating systems.
Every book is about 100 pages long, so it is very easy to get started with a new technology.
They can be read online and can also be downloaded in PDF, MOBI or EPUB format for offline reading. But book download requires account sign up with Syncfusion.
Some of the published books are very recent. Latest book on Blazor Webassembly was published on August 31, 2020.

I went through some of the books. They are well written, easy to follow with great explanation.

Hope you will find them useful!

What are different types of Selectors in CSS?

dev0928 — Fri, 04 Sep 2020 16:56:26 +0000

Photo by Nick Karvounis on Unsplash

One of the complicated parts of CSS declarations is coming with proper selectors we want to apply the style for. Understanding how these selectors work is a great first step in designing a professional looking website. There are multiple ways to select an element for applying styles in CSS. This article attempts to list some of the common selectors with an explanation.

What are Selectors?

Selectors identify elements getting styled in a CSS declaration. In a CSS declaration, selectors are the initial portion that come before curly braces. For example, section HTML element is the selector in the below declaration.

section {
   font-size: 1rem;
   padding: 0.5rem;
   margin: 0.5rem;
 }

What is a DOM?

Before getting into details on common types of CSS Selectors, one must understand how the browsers interpret the HTML page. Browsers try to interpret the contents of the HTML page by parsing them into a DOM. DOM stands for Document Object Model. Quick explanation of DOM can be found here.

Different types of Selectors

Below are some of the most common types of CSS Selectors.

Universal Selectors

Styles applied using universal selectors are applied to all elements on the HTML page. Applying styles this way is considered inefficient as browsers have to parse all elements in the HTML document to apply the style for.

* {
   color: red;  
 }

Element Selectors

HTML elements can be styled using their tag names. With the below CSS, all <h2> tags would be rendered in red color.

h2 {
   color: red;  
 }

Class Selectors

Class selectors are useful if similar styles need to be applied to different parts of the application. Class selectors are defined using . followed by the class name like shown below:

.a-class {
   color: red;  
 }

ID Selectors

Id attribute in HTML is used to uniquely identify an HTML element. These ids could also be used to style an element using # followed by the id.

#my-id {
   color: red;  
 }

Attribute Selectors

HTML elements could be styled based on the presence of an attribute using the Attribute selector. For example below declaration would add border to any element with disabled attribute.

[disabled] {
   border: 2px solid black;     
 }

Group Selectors

If more than one class or element share the same styles they could be comma separated and defined with a single declaration to avoid duplication.

#my-id, 
.b-class {
   color: red;  
 }

Compound Selectors

If we want to style only a specific element containing a named class, we could use a compund selector. With the below style declaration, only div elements with class a-class would be styled. Below style will not be applied if an <h1> element happens to have the same a-class.

div.a-class {
   color: red;  
 }

Descendant Selectors

All elements that are nested inside a given element are called descendants. For example, with the below selector we can style all paragraph elements that are nested in the <body> tag.

body p {
   color: red;  
 }

Parent Child Selectors

Parent Child selector is a little more specific than the descendant selector. It only styles the elements that are direct children of the selector defined on the left side. Below declaration applies only to anchor tags that are immediate children of paragraph tag. If <a> tag happens to be nested inside another <span> tag it will not receive the style.

p > a {
   color: blue;     
 }

General Sibling Selectors

General sibling selectors help style all siblings that are defined after the given selection. With the below selector one can style all paragraph elements that are defined after the <div> and are siblings of the <div> element.

div ~ p {
   color: red;  
 }

Adjacent Sibling Selectors

Adjacent sibling selector styling is similar to the general sibling selector except style will be applied to only the sibling that comes right after the selector.

div + p {
   color: red;  
 }

Pseudo Class Selectors

Pseudo class selectors help in styling a given state of an element. Below styles get applied when a user hovers over an anchor tag.

a:hover {
   color: red;
   text-decoration: none;   
 }

Pseudo Element Selectors

Pseudo element selectors help style part of an element. Pseudo elements styling is declared using :: in CSS3. Below selector styles all paragraph elements’ first line.

   p::first-line {
      color: red;
   }

Final Thoughts

Getting comfortable with CSS selectors would help in coming up with precise CSS declaration that aims to style desired parts of the web page in a professional way. This would also help in avoiding making a lot of costly styling mistakes.

How do you use DEV?

dev0928 — Thu, 27 Aug 2020 22:51:55 +0000

Photo by krisna iv on Unsplash

I have to confess - I have several great articles bookmarked over the past few months that I am still trying to catch up 👩‍💻.

Do you have a set schedule to catch up with bookmarked articles?
If tutorials are posted on Dev or any other blogging platform, do you try them out?
Any best practices around blogging platform(s) usage you would like to share?

Thanks!

Get started with front-end web development

dev0928 — Thu, 20 Aug 2020 00:40:39 +0000

Learning front-end web development has become one of the essential skills for developers. Typical web application comprises several technologies and frameworks. Starting with a front-end framework or library without learning foundational web development skills could lead to frustration.

This article attempts to explain a list of fundamental web development skills along with resources to learn them.

How does the web work?

As a web developer, it is very important to understand what happens when a request is made to access a web page.

Resources

This MDN Web Docs is a great resource for learning it.
Here is another article on How does a Internet work? especially this 10 minute youtube video definitely worth its time.

HTML Basics

HTML stands for Hyper Text Markup Language. HTML defines the content and structure of a web page.

What to learn?

Overall structure of a web page including high-level tags like <html>, <head>, <body> and their importance.
Tags introduced in HTML5.
Browser support for newer HTML tags. This can be checked at Can I Use.

Resources

MDN HTML Basics documentation is a great place to start.

CSS Basics

CSS stands for Cascading Style Sheet. If HTML defines the content of a web page, CSS helps in making it a great looking, professional website.

What to learn?

Different ways of defining styles and best practices around them.
How are different types of selectors defined in CSS?
What is specificity?
What are some of the commonly used CSS properties?
Cross browser support for modern CSS features
Knowing how to inspect the style used by a given element on a web page.

Resources

First choice for learning fundamental CSS would be MDN Docs
Another great resource is a CSS Udemy course which covers lot of foundational CSS concepts to several advanced features.

JavaScript Basics

JavaScript is necessary if websites need some sort of dynamic functionality. Consider a simple example of websites that need to display personalized greetings depending on the users’ time of the day. JavaScript is necessary for accomplishing these types of dynamic functionalities.

What to learn?

Understanding fundamentals of the language
Getting comfortable with debugging in JavaScript through Browser's developer console.
Getting familiar with ES6 features

Resources

Again, a great place to pick up fundamentals of JavaScript is MDN Docs’ JavaScript First Steps section.

Further Learning

Free Code Camp’s Responsive Web Design Certification is another great resource for starting a web developer journey.

Photo by Markus Spiske on Unsplash

Build Restful API with Swagger documentation

dev0928 — Thu, 13 Aug 2020 23:18:25 +0000

OpenAPI (formerly known as Swagger) specification is a language agnostic set of specification used for documenting REST APIs. Swagger team joined SmartBear in 2015 and they open-sourced the Swagger specification which is now called OpenAPI specification.

Documenting APIs is one of the most important steps of API development. This way of documenting not only helps fellow developers but also consumers of the API. Also, Swagger enabled APIs could also be quickly tested without the need for going through detailed documentation.

There are several Restful API frameworks that come with OpenAPI documentation support in Python. In this article, similar to my prior blog, let’s walk through an example with Flask-RestPlus which is an extension to the Flask framework.

Project Setup

Create a project folder - mkdir quotes-rest-api
Setup and activate virtual environment - Virtual Environment Setup
Install below packages in project’s virtual environment:

  pip install flask-restplus
  # Flask-restplus needs below version of Werkzeug
  pip install Werkzeug==0.16.0

Application Setup

Create a file called app.py in the project folder and add necessary imports, application setup along with model definition code like shown below:

# necessary Imports
from flask import Flask, jsonify, request
from flask_restplus import Api, Resource, fields
from werkzeug.middleware.proxy_fix import ProxyFix


# application & documentation setup
app = Flask(__name__)
app.wsgi_app = ProxyFix(app.wsgi_app)
api = Api(app, version='1.0', title='Swagger enabled Quotes API',description='A simple Quotes API')

# namespace definition
ns = api.namespace('quotes', description='Quote CRUD operations')

# model definition - would be automatically displayed as part of API documentation
quote = api.model('quote', {
    'id': fields.Integer(readonly=True, description="Quote's unique identifier"),
    'quote_desc': fields.String(required=True, description="Quote"),
    'quote_type': fields.String(required=True, description="quote's type"),
    'author': fields.String(required=True, description="quote's author")
})

Quotes CRUD Operations Setup

Add below DAO (Data Access Object) class to the app.py file. This class is going to be used by API endpoints to perform necessary CRUD Operations. Also, note that quotes are maintained in application's memory as a Python list object.

# Quote class containing CRUD methods
class QuoteDAO(object):
    def __init__(self):
        self.counter = 0
        self.quotes = []

    def get(self, id):
        for q in self.quotes:
            if q['id'] == id:
                return q
        api.abort(404, "Quote {} doesn't exist".format(id))

    def create(self, data):
        q = data
        q['id'] = self.counter = self.counter + 1
        self.quotes.append(q)
        return q

    def update(self, id, data):
        q = self.get(id)
        q.update(data)
        return q

    def delete(self, id):
        q = self.get(id)
        self.quotes.remove(q)


# Initialize DAO & create sample quotes
DAO = QuoteDAO()
DAO.create({'quote_desc':'It always seem impossible until it is done.', 'quote_type': 'Motivation', 'author': 'Nelson Mandela'})
DAO.create({'quote_desc':'With the new day comes new strength and new thoughts.', 'quote_type': 'Motivation', 'author': 'Eleanor Roosevelt'})
DAO.create({'quote_desc':'The secret of getting ahead is getting started.', 'quote_type': 'Motivation', 'author': 'Mark Twain'})

API endpoints for GET and POST operations

Below class defines GET and POST operations for the quotes maintenance. Below code could also be added to the end of same app.py file.

# API Endpoints for listing and creating new quotes
@ns.route('/')
class QuoteList(Resource):
    '''Shows a list of all quotes, and lets you POST to add new quotes'''
    @ns.doc('list_quotes')
    @ns.marshal_list_with(quote)
    def get(self):
        '''List all quotess'''
        return DAO.quotes

    @ns.doc('create_quote')
    @ns.expect(quote)
    @ns.marshal_with(quote, code=201)
    def post(self):
        '''Create a new quote'''
        return DAO.create(api.payload), 201

API endpoints for other operations

Below class is used to define rest of the CRUD operations. Note the use of common namespace decorators for quote id, response and route information.

# API Endpoints for rest of CRUD operations
@ns.route('/<int:id>')
@ns.response(404, 'Quote not found')
@ns.param('id', 'The quote identifier')
class Quote(Resource):
    '''Show a single quote item and lets you delete them'''
    @ns.doc('get_quote')
    @ns.marshal_with(quote)
    def get(self, id):
        '''Fetch a quote given its identifier'''
        return DAO.get(id)

    @ns.doc('delete_quote')
    @ns.response(204, 'Quote deleted')
    def delete(self, id):
        '''Delete a quote given its identifier'''
        DAO.delete(id)
        return '', 204

    @ns.expect(quote)
    @ns.marshal_with(quote)
    def put(self, id):
        '''Update a quote given its identifier'''
        return DAO.update(id, api.payload)

How to test the API?

Add below code to the end of the app.py file, so we could start the application using python app.py command.

if __name__ == '__main__':
    app.run(debug=True)

API endpoints could be tested in the browser itself. Try it Out button (shown below) could be used to GET list of quotes.

Further Learning

What was your "Deliberate Practice" this week?

dev0928 — Wed, 05 Aug 2020 23:01:23 +0000

I recently read a book called So Good They Can’t Ignore You by Cal Newport. In this book, the author tries to explain the concept of why skills trump passion in the quest for work we love by coming up with four rules to become so good they can’t ignore you. The book also has several case studies as evidence for the defined rules.

Rule 1: Don’t Follow Your Passion

With this rule the author tries to explain the fact that if one believes that they have magical hidden passion waiting to be discovered, they will never be happy with their current job or profession. Book also tries to prove the point that there is very little evidence that many people have a hidden passion waiting to be discovered.

Rule 2: So Good They Can’t Ignore You

This rule tries to emphasize the importance of adopting a craftsman mindset which focuses on what one can offer the world as opposed to a passionate mindset - what the world can offer us. To become a craftsman one should acquire rare and valuable skills which the author calls it as career capital. To acquire career capital one must do deliberate practice.

What is deliberate practice?

Doing things we know how to do well is enjoyable, but that is exactly the opposite of what deliberate practice demands. Deliberate practice is an effort that should make one feel uncomfortable while solving or doing it. In other words it should make them stretch and learn or solve something they really didn’t know well when it was started.

Rule 3: Turn Down a Promotion

Rule 3 explains the power of having control. Control over what one can do and how they do it. Having control over one's work is one of the most important traits when creating work they love. Control cannot be pursued if one does not have rare and valuable skills.

Rule 4: Think Small, Act Big

This rule emphasizes the importance of having a mission so that one can have a unifying focus for their career. Mission can be divided into mini achievable projects.

Final Thoughts

The main takeaway of the book is:

Come up with skills that are rare and valuable in your career.
Become good at them by performing deliberate practice on a regular basis.

So, do you do deliberate practice? What was your deliberate practice this week?

Photo by Mike from Pexels

Build RESTful APIs using Python / Flask

dev0928 — Thu, 30 Jul 2020 21:05:14 +0000

Python / Flask framework combination is one of the popular choices for building back-end APIs for a web application. Building an application’s back-end this way gives several options for coming up with a front-end using different technology stack.

In this article, let’s walk through the steps involved in building a simple API for maintaining Quotes using the Flask framework with SQLite database as its datastore.

Project Setup

Create a project folder - mkdir quotes-api
Setup and activate virtual environment - Virtual Environment Setup
Install below packages in project’s virtual environment:

 pip install flask
 pip install flask-sqlalchemy
 pip install flask-marshmallow

Application Setup

Create a file called app.py in the project folder and add necessary imports, application setup code along with Marshmallow library setup like shown below:

from flask import Flask, jsonify, request
from flask_sqlalchemy import SQLAlchemy
from sqlalchemy import Column, Integer, String
from flask_marshmallow import Marshmallow
import os


#Application and database setup
app = Flask(__name__)
basedir = os.path.abspath(os.path.dirname(__file__))
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///' + os.path.join(basedir, 'quotes.db')

db = SQLAlchemy(app)
# Marshmallow library is used for effective object serialization
ma = Marshmallow(app)

Database Setup

Let’s add below code to the app.py file so we could create a quotes database and seed data through the flask commands.

#Database creation flask commands
@app.cli.command('db_create')
def db_create():
    db.create_all()
    print('Database created!')


@app.cli.command('db_drop')
def db_drop():
    db.drop_all()
    print('Database dropped!')


@app.cli.command('db_seed')
def db_seed():
    quote1 = Quote(quote_desc='It always seem impossible until it is done.',
                     quote_type='Motivation',
                     author='Nelson Mandela')

    quote2 = Quote(quote_desc='With the new day comes new strength and new thoughts.',
                         quote_type='Motivation',
                         author='Eleanor Roosevelt')

    quote3 = Quote(quote_desc='The secret of getting ahead is getting started.',
                     quote_type='Motivation',
                     author='Mark Twain')

    quote4 = Quote(quote_desc='With self-discipline most anything is possible.',
                     quote_type='Inspiration',
                     author='Theodore Roosevelt')

    quote5 = Quote(quote_desc='It is during our darkest moments that we must focus to see the light.',
                     quote_type='Inspiration',
                     author='Aristotle')


    db.session.add(quote1)
    db.session.add(quote2)
    db.session.add(quote3)
    db.session.add(quote4)
    db.session.add(quote5)
    db.session.commit()
    print('Database seeded!')


# database model
class Quote(db.Model):
    __tablename__ = 'quotes'
    quote_id = Column(Integer, primary_key = True)
    quote_desc = Column(String)
    quote_type = Column(String)
    author = Column(String)


# Quote model added to the Marshmallow library for JSON serialization
class QuoteSchema(ma.Schema):
    class Meta:
        fields = ('quote_id', 'quote_desc', 'quote_type', 'author')


quote_schema = QuoteSchema()
quotes_schema = QuoteSchema(many=True)

Execute below code in project’s virtual environment to create and seed the quotes data:

flask db_create
flask db_seed

CRUD Operations

Now that all of the setup part is complete, below methods added to the app.py file help perform the actual CRUD (Create, Read, Update and Delete) operations. Note the appropriate use of HTTP Methods and status codes to signify success or failure of a particular API endpoint.

Read Endpoint

@app.route('/quotes', methods=['GET'])
def quotes():
    quotes_list = Quote.query.all()
    result = quotes_schema.dump(quotes_list)
    return jsonify(result)


@app.route('/quote_details/<int:quote_id>', methods=['GET'])   
def quote_details(quote_id: int):
    quote = Quote.query.filter_by(quote_id=quote_id).first()
    if quote:
        result = quote_schema.dump(quote)
        return jsonify(result)
    else:
        return jsonify(message="That quote does not exist."), 404

Add Endpoint

@app.route('/add_quote', methods=['POST'])   
def add_quote():
    quote_desc = request.form['quote_desc']
    test = Quote.query.filter_by(quote_desc=quote_desc).first()
    if test:
        return jsonify(message="There is already a quote by that description."), 409
    else:
        quote_type= request.form['quote_type']
        author= request.form['author']
        quote =  Quote(quote_desc=quote_desc,
                         quote_type= quote_type,
                         author= author)  
        db.session.add(quote)
        db.session.commit()                 
        return jsonify(message="Quote added successfully!"), 201

Update Endpoint

@app.route('/update_quote/<int:quote_id>', methods=['PUT'])   
def update_quote(quote_id : int):
    quote = Quote.query.filter_by(quote_id=quote_id).first()
    if quote:
        quote.quote_desc = request.form['quote_desc']
        quote.quote_type = request.form['quote_type']
        quote.author= request.form['author']
        db.session.commit()                 
        return jsonify(message="Quote successfully updated!")
    else:
        return jsonify(message="That quote does not exist"), 404

Delete Endpoint

@app.route('/remove_quote/<int:quote_id>', methods=['DELETE'])   
def remove_quote(quote_id : int):
    quote = Quote.query.filter_by(quote_id=quote_id).first()
    if quote:
        db.session.delete(quote)
        db.session.commit()                 
        return jsonify(message="Quote successfully deleted!"), 200
    else:
        return jsonify(message="That quote does not exist"), 404

How to test the API?

Add below code to the end of the app.py file, so we could start application using python app.py. API endpoints could be tested using Postman application.

if __name__ == '__main__':
    app.run()

Next Steps:

Extend API to provide more endpoints
Secure API using JWT
Build a front-end using react.js, vue.js or any other suitable technology
Deploy built API by installing WSGI complaint server on any of the cloud platforms