DEV Community: Kenzy Limon

Low code is undoubtedly the future of innovating faster and better software.

Kenzy Limon — Thu, 05 Oct 2023 20:36:02 +0000

If you're into tech or software development, you might have heard of the term Low-Code, for some, you might have a not-so-good opinion of it, and I understand where you’re coming from, just bear with me on this one.

So what is this thing called Low-Code: Well its a software development technique that enables IT developers to build applications with minimal coding.

it's able to understand both developers and product owners by allowing non-technical users {business/designers} and developers to apply their skill sets, collaborate, and co-develop solutions.

Though some developers see it as a short-term solution to building long-lasting software, there are Low-Code Platforms that have proven to offer long-lasting solutions with some having full code generation.

Gartner predicts that most enterprises will adopt Low-Code solutions in software development. As of 2023, the market revenue is at $26.9 billion from $7.8 billion in 2018.

To conclude: Whether developers like it or not, we don't really have a better solution at the moment, in a world where ideas and innovation are at their highest, the demand for building fast reliable software is needed now more than ever, we need to adapt and adapt really fast from the traditional ways of scaffolding every project from scratch.

Meet Fiber: Super Fast Golang Framework Part 2

Kenzy Limon — Wed, 10 May 2023 09:27:04 +0000

There are a lot of Go frameworks out there, and choosing the best one that can scale, has consistent performance, and has rich features to build and maintain a project through its production stages.

Factors to consider when choosing the right Golang framework should be :

Complexity

Go language by itself is made to be powerful and simple, when you’re picking a framework look for the one that does not go against the nature of Go language. Fiber framework is made in such a way that any express js developer will find it similar, it does this while giving Golangs great performance and features.

Community

As with any new framework. Fiber framework has a new small growing community compared to other Golang frameworks. it has 26.2k GitHub stars at the time of writing.

Documentation & Resources

There are things developers really appreciate the most, and that is nicely done documentation. documentation that is well covered, organized, and examples included, and if a nice UX/UI is added that’s a plus too 🤩.

Fiber framework has nice documentation that lives you happy while learning. It makes debugging and learning an easy process. You can join the Fiber Discord community to share, engage and gain more insight into the framework.

Meet Fiber: Super Fast Golang Framework Part 1

Kenzy Limon — Tue, 09 May 2023 22:29:52 +0000

Fiber

Designed to ease things up for fast development with zero memory allocation and performance in mind.

Fiber Framework is built to make Go web development feel like NodeJS Express architecture.

This great framework is built on top of Fasthttp, the fastest HTTP engine for Go. As seen below, the fiber framework outperformed other well-known frameworks in a Web Framework Benchmark round 21, which measured the performance of several web application platforms, full-stack frameworks, and micro-frameworks (collectively, “frameworks”).

Fiber at 22
NodeJs at 81
Phoenix at 113
Express at 116
Laravel at 130
Django at 137

For more information, read the introduction, motivation, and latest environment details.

several cases where companies have lost control of their domain names

Kenzy Limon — Sat, 07 Jan 2023 10:49:49 +0000

There have been several cases where companies have lost control of their domain names due to a variety of reasons. See some of the top trending companies' case studies that have led to this Article:

Case 1 in 2013: Regions Online Bank forgot to pay their domain renewal bill. Customers couldn’t log in to regions.com accounts, prompting a wave of concern 🤯.
Case 2 in 2015: Google amost sold google.com for $12. former Googler was checking out Google Domains when he saw that google.com was for sale. the ownership didn’t last long, though. Google Domains canceled the order because they controlled both the domain and registry service 🤔.
Case 3 in 2018: The Avengers forgot to register their game out domain-name endgame, By the time endgame trailer was being released, fans were being directed to the “Once Upon a Deadpool” site instead, creating exactly the kind of chaos that Deadpool thrives on. The solution was latter found after @GuyInChair, a Twitter user who offered to trade the domain for Endgame premiere tickets 🤩.

These cases demonstrate the importance of properly managing and renewing domain names to avoid losing control of them and that if ignored it can affect all most every industry.

It is important for companies to keep track of the expiration dates of their domain registrations and to renew them in a timely manner to avoid such incidents.

Create a Bare Minimum Chrome Extension App (Taskan)

Kenzy Limon — Fri, 06 Jan 2023 00:48:51 +0000

There is a chance an extension might be a viable solution to that native code integration limitation your having on your web platform.

All about Chrome Extension

Chrome Extensions are software programs, built on web technologies (such as HTML, JavaScript, CSS, and some resource Assets) that enable users to customize the Chrome browsing experience.

Some benefits of Chrome Extensions 🎅🏾

Chrome Extensions have the advantage of benefiting from JavaScript APIs that the browser provides. Their access to Chrome APIs makes them more potent than a web app. The following are just a few examples of what extensions can do:

Change the functionality or behavior of a website.
Allow users to collect and organize information across websites.
Add features to Chrome DevTools.
Change website design (layout, style, and appearance of websites).
Some have the ability to block or filter Ads.
Enhance Security.

What are Chrome Extension files.? 🤔

When building a chrome extension there are a few things and guidelines you need to take into thought before you start development.

Chrome Extensions contain different files, depending on the functionality provided. The following are some of the most frequently used files:

Manifest file: This file should be named strictly as manifest.json and has to be located in the root directory. This file is also responsible for recording important metadata, defining resources, and permission declarations, and indicating which files to run in the background.

Service worker: This file handles and listens for browser events. There are many events, such as navigating to a new page, removing a bookmark, or closing a tab. It can use all the Chrome APIs.

Content scripts: This file executes Javascript in the context of a web page. They can also read and modify the DOM of the pages they're injected into. Content Scripts can only use a subset of the Chrome APIs but can indirectly access the rest by exchanging messages with the extension service worker.

Let's start the development

The Tech Stack of this project was based on a number of factors that lead to Flutter as the preferred framework.

Quick Introduction to Flutter 📽️

Flutter is a simple and high-performance multiplatform framework based on Dart language, which provides high performance with a native look and feel. you can find a brief introduction to flutter, an easy computer setup guide, and some of its features that make it the ninja of all platforms right below this Dot.

Flutter is a cross-platform UI toolkit designed to allow code reusing across multiple platforms such as iOS, Android, Web, and Desktop.

Lets get Technical 🕹️

We will start by creating a new Flutter project
using the flutter create command. use your preferred cli and input the following commands.

flutter create taskan

The main.dart file is the one we will be focusing on, that's where our logic and view will be.

Don't get worried when folder structures don't match, just make sure you have the necessary ones ( lib, web, and pubspec.yaml ) and the rest we won't be needing in our coverage.

Your lib/main.dart should look like this:

Part 2 Coming next...

Follow us as we get to cover and learn interesting topic about api / websocket with race conditions, distributed systems, machine learning and ai development.

A bit about Go Programing language

Kenzy Limon — Mon, 12 Dec 2022 08:41:02 +0000

Golang is an open source programming language developed by Google engineers to allow developers to build fast, reliable, and efficient software at scale with memory safety, garbage collection, structural typing and CSP-style concurrency.

Features in Golang

Easy to learn and get started with
Built-in strong concurrency and a robust standard library
High productivity & simplified usage
Outstanding level of code efficiency ( Concise and Clear )
No need for external dependency, Go can easily produce native binaries

Companies using it

Golang has been tried and tested with its distinct advantages, it has been the best choice for world-class products and industry giants.

Google
PayPal
Netflix
Twitter
Uber

Frameworks

Ideal Stack Setup

Gin :- Golang MVC Framework
Tailwind CSS :- UI framework that allows CSS inside HTML
Alpine JS :- Tiny Javascript for client macro interactions

Comunity Support

Golang application development with swiftness, easy grasping, highly accessible development tools, fully stable & concurrent and above all, awesome Go community support.

Originally posted from Why Choose Golang over Elixir in backend development

How to Practice Root Cause Analysis in tech problems

Kenzy Limon — Thu, 01 Dec 2022 08:08:57 +0000

RCA is a collective term used to describe a wide range of approaches, tools, and techniques to uncover causes/events that happened.

Root Cause Analysis is a process of determining the underlying reasons for an event so that the most effective solutions can be observed or implemented towards an organization’s strategy for continuous improvement efforts.

Note : This process generally serves as an input to a remediation process whereby corrective actions need to be taken to prevent the problem from reoccurring again or when something works effectively and how to replicate it across all processes.

Common Techniques

These tools allow for analysis to be branched in order to provide multiple root causes.

a) Cause and Effect Analysis (also known as Fishbone Diagrams)
b) 5 Whys (also known as 5Y)

How Root Cause Analysis is Applied

RCA It is widely used in IT operations, telecommunications, market research, industrial process control, accident analysis (e.g., in aviation, or nuclear plants), medicine (for medical diagnosis), healthcare industry (e.g., for epidemiology), etc.

RCA offers strategic, simple, effective ways for uncovering the root of a problem. You can use it in troubleshooting, problem-solving, and quality-improvement initiatives.

Want to keep in touch online? Medium | Twitter | Instagram

Getting Started on Elixir and Ecto Part 7

Kenzy Limon — Wed, 16 Nov 2022 21:30:18 +0000

Deleting Data

Similar to updating, we must first fetch a record from the database and then call Taskers.Repo.delete to delete that record:

Similar to insert and update, delete returns a tuple. If the deletion succeeds, then the first element in the tuple will be :ok, but if it fails then it will be an :error.

This marks the end of our 7 part Elixir Ecto tutorial, if you’ve missed some parts, feel free to go through My profile posts and you can find a detailed scope of the topic.

Getting Started on Elixir and Ecto Part 6

Kenzy Limon — Mon, 07 Nov 2022 11:40:22 +0000

Updating Data

Updating records in Ecto requires us to first get a record from the database then create a changeset from that record and pass the new changes we want to make to that record, and finally, call the Ecto.Repo.update function.

Getting Started on Elixir and Ecto Part 5

Kenzy Limon — Fri, 04 Nov 2022 12:32:17 +0000

Querying Data

Querying a database requires two steps in Ecto. First, we must construct the query, and then we must execute that query against the database by passing the query to the repository.

The Ecto.Repo.one function will only return a struct if there is one record in the result from the database and an error if there exists more than one record. Let’s start off with fetching just one record from our tasks table.

To fetch all records from the schema, Ecto provides the all function:

Taskers.Tasks |> Taskers.Repo.all

To fetch a record based on its ID, you use the get function:

Taskers.Tasks |> Taskers.Repo.get(1)
#=> %Taskers.Tasks{__meta__: #Ecto.Schema.Metadata<:loaded, "tasks">, id: 1, title: "Hello World", ...}

If we want to get a record based on something other than the id attribute, we can use get_by:

Taskers.Tasks |> Taskers.Repo.get_by(title: "Hello World")
#=> %Taskers.Tasks{__meta__: #Ecto.Schema.Metadata<:loaded, "tasks">, id: 1, title: "Hello World", ...}

If we want to get multiple records matching a specific attribute, we can use where:

Taskers.Tasks |> Ecto.Query.where(title: "Hello World") |> Taskers.Repo.all

NOTE: One important thing to note with Ecto query syntaxes is that they require variables to be pinned, using the pin operator (^). The pin operator instructs the query builder to use parameterized SQL queries to protect against SQL injection.

title = "Hello World"
Taskers.Tasks |> Ecto.Query.where(title: ^title) |> Taskers.Repo.all

Ecto queries can be built up by calling Ecto.Query functions on existing queries.

Getting Started on Elixir and Ecto Part 4

Kenzy Limon — Wed, 02 Nov 2022 16:05:07 +0000

Creating and Validating input Data

To insert a new record into our tasks table, run this code:

task = %Taskers.Tasks{}
Taskers.Repo.insert(task)

To insert the data into our database, we call insert. which is the module that uses Ecto to talk to our database. A successful insertion will return a tuple, like so:

{:ok, %Taskers.Tasks{__meta__: #Ecto.Schema.Metadata<:loaded, "tasks">, title: nil, id: 1, ...}}

The :ok atom can be used for pattern matching purposes to ensure that the insertion succeeds.

{:ok, tasks} = Taskers.Repo.insert person

NOTE: In Ecto, you may wish to validate changes before they go to the database. For this, Ecto has changesets. Changeset will only allow defined parameters through and anything not in the list will be ignored.

This insertion will fail since the required values are not passed. The first return element is a tuple :error which contains the specifics of the error

We can access these error messages by doing some pattern matching:

NOTE: Since changeset had errors, no record was inserted into the tasks table. For a better way to handle changeset, use a case statement on the turple.

To show these error messages in a more human-friendly way, we can use Ecto.Changeset.traverse_errors/2:

This will return the following output:
%{   
   user_id: ["can't be blank"],
   title: ["can't be blank"],
 }

Getting Started on Elixir and Ecto Part 3

Kenzy Limon — Fri, 21 Oct 2022 17:34:41 +0000

Schema, Changeset and Data types

At this point, you might start to wonder why you are doing essentially the same thing twice when dealing with Schema and Changeset.

While migrations are liable for giving us the database tables, schemas are liable for how Ecto interacts with those tables.

A schema is an Elixir declaration of data from our database. Besides working as data mappers, embedded_schema/1 and schema/2 can also be used together to decouple how the data is represented in your applications from the database.

schema/2 is typically used to map data from a persisted source, usually a database table, into Elixir structs and vice-versa.

embedded_schema/1 is used for defining schemas that are embedded in other schemas or only exist in memory without ever persisting elsewhere.

Changesets define a pipeline of transformations our data needs to undergo before it will be ready for our application to use. These transformations might include type-casting, user input validation, and filtering out any extraneous parameters.

NOTE: You can actually use an embedded schema to depict your UI, mapping and validating its inputs, and then you convert such embedded schema to other schemas that can persist data to the database.

NOTE: The naming convention in Ecto for schemas is a singularized name.

ECTO TYPE  -> ELIXIR TYPE  -> LITERAL SYNTAX IN QUERY

:id -> integer  { 1, 2, ...}
:binary_id -> binary  { <<int, int, ...>> }
:integer -> integer  { 1, 2, ...}
:float -> float  { 1.0, 2.0, ... }
:boolean -> boolean  { true, false }
:string -> UTF-8 encoded string  { "hello" }
:binary -> binary { int, int, ... }
{:array, inner_type} -> list { [value, value, ...] }
:map -> map
{:map, inner_type} -> map
:decimal -> Decimal
:date -> Date
:time -> Time
:time_usec -> Time
:naive_datetime -> NaiveDateTime
:naive_datetime_usec -> NaiveDateTime
:utc_datetime -> DateTime
:utc_datetime_usec -> DateTime

You can easily play around with schema by simply starting an IEx iex -S mix

task = %Taskers.Task{}

We can set values on these fields by generating a new struct:
task = %Taskers.Task{estimated_time: 28}
task = %{task | estimated_time: 3.0}

And retrieve values using this syntax:
task.estimated_time # => 3.0