DEV Community: Kairus Noah Tecson

Vector Search Metrics 🎯: Why Your "Distance" Might Be Wrong

Kairus Noah Tecson — Fri, 06 Feb 2026 03:02:19 +0000

I initially thought integrating vector databases would be as simple as learning any other Python library, assuming I could skip complex configurations until later. I was wrong. Tools like Milvus required an immediate deep dive into specific settings, such as metric types, before I could even successfully interact with the database.

The Metric Type.

This isn't just a random math preference that you can just choose for the sake of it; it’s the definition of "similarity" between each data that you have in your vector database. Mathematically speaking, it defines how we can measure the distance between two chunks in a vector space. It can be through the straight line distance between each other, it can be based on the angle of difference, or it can also be using both measurements.

Definition of the metric type is first based on one thing: the type of data you are working with. Second one is based on the embedding model you are using which must be based also on the type of data you are working with, whether it is an image, text, or audio (that is why this must be second thing to consider).

It is defined during the index setup, and if you get it wrong, you’re essentially speaking a different language than your embedding model. Two vectors might look "close" in a straight line in the vector space, but semantically, they could be unrelated.

Here is the breakdown of the three main metric types and when to actually use them.

1. Cosine Similarity (The NLP Standard)

What it measures: The angle between two vectors.
What it ignores: Magnitude (length).

For text and NLP, this is usually your default. Modern dense embedding models encode semantic meaning in the direction of the vector, not the length.

Think of it this way:

Vector A: The sentence "I love cats."
Vector B: A 500-word essay about how much the author loves cats.

If you plot these, they will point in roughly the same direction (high cosine similarity) because the topic is identical. However, Vector B will likely have a much larger magnitude because it has more words/features. If you used a distance metric that cared about length, these two documents would seem far apart. Cosine ignores the length and focuses purely on the vibe (direction).

Note on Sparse vs. Dense: In older sparse vector models (like TF-IDF), magnitude represented word frequency or importance. In modern dense embeddings (like OpenAI’s text-embedding-3), magnitude is often normalized or irrelevant to meaning.

2. L2 / Euclidean Distance (The Physical Distance)

What it measures: The straight-line distance between points in space.
What it cares about: Both direction and magnitude.

Euclidean distance is what we typically think of when we say "distance" in the real world—measuring with a ruler from point A to point B.

When to use it:
This is heavily used in Computer Vision (images) and Audio processing.

In image data, the "magnitude" often carries valid information, such as pixel intensity, color depth, or the sheer number of features present. If you have a dark image and a bright image of the same object, the pixel values are different, creating a distance in the vector space that L2 captures effectively.

3. Inner Product (IP) (The Speed Demon)

What it measures: The projection of one vector onto another.
What it cares about: Direction and magnitude.

This is the standard for Recommendation Systems. In these use cases, magnitude often correlates with the "strength" of a user's preference or the popularity of an item. You want to capture both what they like (direction) and how much they like it (magnitude).

The "Free" Performance Hack

Here is a trick that is worth knowing if you are optimizing for scale.

If your embedding model outputs normalized vectors (vectors with a length of 1), Inner Product (IP) and Cosine Similarity become mathematically equivalent in terms of ranking order.

Why does this matter?
IP is computationally cheaper to calculate than Cosine.

Cosine requires a division operation to normalize the vectors during the calculation. If you know your vectors are already normalized (which many modern models do by default), you can set your metric type to IP to get the same accuracy as Cosine, but with faster search performance.

TL;DR

Don't just leave the metric type on default.

Text/RAG? Check your model documentation. It's usually Cosine.
Images/Audio? Likely L2 (Euclidean).
Normalized Embeddings? Use IP for a free speed boost.

🥽 Deep Dive: Understanding Contextual Recall 🎯 in RAG Systems

Kairus Noah Tecson — Wed, 04 Feb 2026 09:30:30 +0000

Definition & Calculation

Contextual Recall measures the semantic completeness of your retrieval system. It is calculated by first generating a list of claims or statements from the Expected Output (Ground Truth) of the RAG system.

Using an LLM (typically the same model used to generate the claims), this list is mapped against the Actual Retrieved Chunks. The goal is to determine if the statements generated from the expected output can be semantically satisfied or concluded from the retrieved chunks.

The metric is calculated as:

A perfect score implies that all statements in the expected output are supported by the retrieved context, regardless of whether a single chunk satisfies multiple statements or multiple chunks satisfy a single statement.

The Problem with Typical Recall (Recall@K)

Contextual Recall solves the limitations of typical recall metrics (like Recall@K), which rely on comparing a static list of Expected Document IDs against the Actual Retrieved IDs.

In typical recall, if a specific chunk ID from the expected list is missing from the retrieval results, the system is penalized—even if the actual retrieved chunks contain the exact same information semantically.

This rigidity is critical because of Vector Space Volatility:

The Scenario: Consider two semantically similar queries, User Query A and User Query B.
The Vector Space: When mapped into the vector database, their positions will differ slightly. This slight difference is significant and can greatly affect the ANN (Approximate Nearest Neighbor) results.

The Outcome: Query A might retrieve chunks {A, B, C}, while Query B might retrieve only {A, B} because its position shifted just enough to place Chunk C outside its reach scope. In a typical recall metric, if Chunk C was "expected," Query B would be penalized. However, in Contextual Recall, if Chunks A and B provide sufficient information to answer the prompt (or if a different Chunk D provides the same info as Chunk C), the system is not penalized, resulting in a more accurate reflection of system performance.

What It Measures: Diagnosis & Root Causes

Low Contextual Recall evaluates the alignment between your Indexing Strategy (Chunking + Embedding) and your Retrieval Strategy (Query Embedding). A low score typically implies one of the following system failures:

1. Poor Embedding Model Performance

The embedding model may perform poorly due to its training methodology or dimensionality:

Training Bias: If the model was trained poorly, it may overly index or focus on specific terms in a chunk, skewing its numeric representation.
Low Dimensionality: If the embedding dimensions are too low for the complexity of the data, the model lacks the granularity to represent the chunk's meaning accurately.

2. Domain Mismatch (Non-Specialized Models)

This occurs when a general-purpose embedding model is used for specialized domains (e.g., medical or legal) containing heavy jargon.

Example: If a user searches for "ADHD," the query implies related concepts like "hyperactivity," "impulsiveness," and "inattention."
The Failure: A general-purpose model might not understand that a chunk describing "inattentive behavior" is semantically equivalent to "ADHD." Consequently, it fails to capture the relationship, ignores the relevant chunk, and degrades retrieval performance.

3. Chunking Strategy Failures

Improper chunking leads to improper positioning in the vector space, meaning the chunk's semantic value is misrepresented.

Under-Segmentation (Chunk Size Too Large): When a chunk is too large, it often includes multiple distinct claims or topics. The embedding model attempts to create a single vector that "balances" all these statements.
- The Consequence: The resulting vector might sit on the borderline between Topic A and Topic B. Even if the chunk contains significant information about Topic A, it is treated poorly during retrieval because its position is diluted by Topic B. This "averaging effect" lowers the confidence score for specific queries.

Over-Segmentation (Chunk Size Too Small): When a chunk is too small, it lacks sufficient context for the model to draw meaningful conclusions.
- The Consequence: The embedding model cannot accurately represent the information because the fragment is semantically incomplete, leading to a vector that effectively represents noise.

References:

💼 This Portfolio Rearranges Itself Based on Your Job Description

Kairus Noah Tecson — Fri, 30 Jan 2026 22:39:31 +0000

This is a submission for the New Year, New You Portfolio Challenge Presented by Google AI

About Me

Hey there! 👋 I'm Kairus Noah Tecson, a Head of Engineering based in the Philippines with a passion for building AI-powered platforms and agentic workflows.

Here's the problem I wanted to solve: Recruiters spend seconds scanning portfolios. They're looking for specific keywords, relevant projects, matching experience—and they don't have time to dig through your entire work history to find it.

So I asked myself: What if my portfolio could do the digging for them?

The result is a portfolio that reads your job description and reorganizes itself to show the most relevant content first. Paste a JD, and watch the sections reorder and highlight in real-time.

Portfolio

URL: https://www.schadenkai.space/

How I Built It

🛠️ Tech Stack

Layer	Technology
Frontend	Next.js 14 (App Router), TypeScript, Tailwind CSS
AI Engine	Gemini 2.5 Flash via Vertex AI
State Management	Zustand
Animations	Framer Motion
Deployment	Docker + Google Cloud Run
DNS / CDN	Cloudflare (Free Tier)

🧠 How the Rearranging Works

The portfolio has two layers:

The Chat Interface (Hero): Paste a job description or ask a question like "Do you have experience with RAG systems?"
The Portfolio (Content): Sections dynamically reorder (e.g., Projects slides above Experience) and specific items get highlighted based on relevance.

🤖 The AI Behind It

Gemini 2.5 Flash analyzes your input and returns a structured JSON configuration:

{
  "layout_order": ["projects", "experience", "skills"],
  "highlight_ids": ["project-0", "skill-2"],
  "message": "I've prioritized your AI/ML projects and Python skills..."
}

This JSON updates a Zustand store, which triggers Framer Motion animations for smooth section transitions. The whole flow takes under 2 seconds.

🎨 Design: Neo-Brutalism

Bold borders. Hard shadows. Vibrant accents (purple, yellow, pink). The aesthetic is inspired by a "creative workshop" vibe—the chat interface feels like a command center that controls the portfolio below.

What I'm Most Proud Of

🔄 The Live Rearranging

Watching "Projects" smoothly slide above "Experience" because the AI decided it's more relevant to a Frontend role.

✨ Smart Highlighting

Relevant skills and projects get a visual boost (border glow, background tint) so recruiters can scan faster. The AI picks which items to highlight based on keyword matching from the job description.

🎮 Hidden Easter Eggs

Stay around the hero section and you might find animated sprites — a running knight, bouncing slimes, spinning coins. Because portfolios should have personality.

🚀 $0.00/month Infrastructure

Service	Monthly Cost
Vertex AI (Gemini 2.5 Flash)	$0.00 (free tier)
Google Cloud Run	$0.00 (2M requests free)
Cloudflare DNS	$0.00
Total	$0.00

Rate limiting (5 req/min, 20 req/day per user) keeps costs at zero while preventing abuse.

Try it yourself! Paste a job description into the chat and watch the portfolio adapt. I'd love to hear what you think. 🙏

🐙 GitHub
💼 LinkedIn

Load Testing using FastAPI and Postman: A Comprehensive Guide

Kairus Noah Tecson — Fri, 13 Dec 2024 00:30:54 +0000

Imagine this scenario wherein your startup app starts to have traction. Users count suddenly goes up! And now continuously grows from 10 to 100 users. All those users constantly do things in your app, clicking some buttons, using some features, making request from your backend server...

What you would not want in this kind of situation is unpreparedness. You want to ensure that your application is Reliable and Available to the users. This is where Testing comes into place and what we would be talking about here is a specific type of testing that is suitable for testing this kind of scenarios, Load testing.

In this guide, we’ll focus on using FastAPI and its automated OpenAPI specification generation to streamline the process of generating Postman collections for load testing. By the end, you’ll know how to utilize FastAPI’s OpenAPI specification and Postman to test your application at scale.

🤔 Why Use FastAPI and Postman for Load Testing?

FastAPI comes with built-in OpenAPI support, making it easy to document and test your APIs. By combining FastAPI with Postman, you can:

Automatically generate Postman collections from your FastAPI API’s OpenAPI documentation.
Simplify request setup by importing the collection directly into Postman.
Leverage Postman’s powerful testing and scripting features for dynamic data generation.
Scale tests programmatically with Newman, Postman’s CLI tool, for CI/CD integration.

This synergy between FastAPI and Postman allows developers to quickly simulate real-world traffic scenarios and identify bottlenecks in their applications.

🛠️ Step 1: Setting Up FastAPI and Swagger

1.1 Start Your FastAPI Application

Ensure your FastAPI application is running locally or on a server. For example:

from fastapi import FastAPI

app = FastAPI()

@app.get("/items/{item_id}")
def read_item(item_id: int, q: str = None):
    return {"item_id": item_id, "q": q}

if __name__ == "__main__":
    import uvicorn
    uvicorn.run(app, host="0.0.0.0", port=8000)

When the server starts, OpenAPI JSON endpoint will be available at http://127.0.0.1:8000/openapi.json.

1.2 Verify OpenAPI JSON

Open your browser and navigate to http://127.0.0.1:8000/openapi.json to ensure the OpenAPI JSON is accessible.

🚌 Step 2: Exporting the OpenAPI JSON to Postman

2.1 Copy the OpenAPI endpoint

You can either save the OpenAPI JSON file locally by using your browser or by curl:

curl -o openapi.json http://127.0.0.1:8000/openapi.json

Or just by copying the OpenAPI endpoint URL, http://127.0.0.1:8000/openapi.json.

2.2 Import OpenAPI JSON into Postman

Open Postman and click Import in the top-left corner.
Select the downloaded openapi.json file.
Postman will automatically generate a collection with all the endpoints defined in the OpenAPI specification.

If you just copied the endpoint URL, you can just paste the URL at the input bar at the top of the modal that appears when you click the Import

2.3 Organize and Test Your Collection

Review the imported collection to ensure all endpoints are correctly configured. You can also add environment variables or scripts as needed for authentication or data management.

📦 Step 3: Preparing for Load Testing in Postman

3.1 Add Dynamic Data to Your Requests

To simulate real-world scenarios, modify your requests to include dynamic data. For example, use Postman’s built-in variables or pre-request scripts:

Example Pre-request Script:

pm.variables.set("random_id", Math.floor(Math.random() * 10000));

Example Payload:

{
    "item_id": "{{random_id}}",
    "q": "sample_query"
}

You can also just make use of built-in scripts like $randomInt to generate random values.
Example use case of using built-in scripts:

{
  "email": "user_{{$randomInt}}@gmail.com",
  "password": "DevPassword123",
  "full_name": "Testing 1_{{$randomInt}}",
  "company_name": "Testing Company"
}

This built-in script will return random values between 0-1000 in every request made.

3.2 Configure Variables in you Collection

Use collection variables in Postman to manage API base URLs, authentication tokens, or dynamic parameters without your Collection. This simplifies updates and testing across your Collection.

🧪 Step 4: Running Performance Tests with Postman's Collection Runner

Postman now includes built-in performance testing capabilities that allow you to simulate user traffic and assess your API's performance.

4.1 Launch the Collection Runner

Click on the Runner button (beaker icon) in Postman.
Select the collection imported from your FastAPI OpenAPI JSON.4.2 Set Test Parameters

4.2 Configure Performance Test Settings

Virtual Users: Specify the number of virtual users to simulate concurrent load.
Test Duration: Set the duration for which the test should run.
Load Profile: Choose between fixed, ramp-up, spike, or peak load profiles to simulate different traffic patterns.4.3 Execute the Load Test

4.3 Execute the Performance Test

Click Run to start the performance test. Postman will display real-time performance metrics such as average response time, error rate, and throughput.

📈 Step 5: Analyzing Test Results

After the test completes, analyze the results to identify performance bottlenecks:

Response Times: Check if the response times meet your application's performance criteria.
Error Rates: Identify any errors that occurred during the test and investigate their causes.
Throughput: Assess the number of requests handled per second to ensure it aligns with expected load.

Postman provides detailed metrics and allows you to compare multiple test runs to track performance changes over time.

🚀 Best Practices for Load Testing with FastAPI and Postman

Keep OpenAPI Documentation Updated: Ensure your FastAPI documentation reflects the current state of your API for accurate testing.
Use Dynamic Data: Incorporate variability in test data to simulate diverse real-world scenarios.
Monitor System Resources: Use monitoring tools to observe CPU, memory, and network usage during tests.
Automate Tests: Integrate performance tests into your CI/CD pipeline for continuous assessment.
Iterate Based on Findings: Regularly update your tests and application based on performance test outcomes.

📌 Conclusion

By leveraging FastAPI's OpenAPI specification and Postman's performance testing features, you can effectively simulate user traffic and identify potential performance issues. This approach enables you to ensure your FastAPI application remains robust and responsive under varying load conditions.

Happy testing!

Officially graduated: What now?

Kairus Noah Tecson — Wed, 14 Aug 2024 09:19:33 +0000

It has really been long time since I've created a post. I am still 3rd year college that time when I have created my articles here in Dev.to. But times really flies fast. I just graduated in Computer Science here in the Philippines.

But what now?

I already have acquired a fulltime job in a startup company in Austria months before my graduation. And it has been the greatest teacher for me ever since, greater than all the professors that I have in the university. Startup teaches you a lot of things and fast. But of course, in exchange of some bite off your insanity. But yeah, as I always tell myself and to others, great pressure comes with great experience.

But even after having a stable job after the official class ends, I stumbled on a common trap when people reach there long live dream, I become lost. Though I am already aware of this, I just can't avoid feeling lost, down, and depressed. I always thought that if I will be having another long-term goal again, I can be free from the sadness and emptiness, but no. I always have a lot of long-term goals in mind after graduation. That is to become proficient software engineer, build a startup company, etc.

This has been my state for about 2 weeks after the class officially ends (before graduation day). Right now, I got back my vigor to learn and improve in the field of my passion. What is the solution then? How did I overcome this emptiness? I don't have a scientific and concrete answer if that is what you are finding in this article. What I did is I write. I listed out what is the reason why I started in the first place. Why did I eagerly grind in the past, even sacrificing my social life and attendance count. That is the time when I got back my fire to pursue all my other long-term goals that has been brushed off by my emptiness. After that, I planned everything out again. What will be my goal for the next 1, 3, and 5 years from now. And what will be the things I need to do and incorporate in life to be able to reach those goals.

Right now, I am still working on the startup company as a tech lead of our small and only development team. I am still learning and surely have a long way to go to become proficient software engineer. I will now be posting on my blog regularly every week about my journey to become a Software Engineer, you can join me in my journey by following me. Thank you.

Learn Anything 10x Faster: Outliers Guide – Part 2

Kairus Noah Tecson — Tue, 29 Aug 2023 04:16:44 +0000

Introduction

In our journey through life, learning is a constant companion. It's not an innate talent but a skill that separates the average from the extraordinary. In this blog series, we delve into the secrets of accelerated learning. In this installment, we explore three essential elements to supercharge your learning process.

1. Meta-learning: Learning How to Learn

Meta-learning, often described as "learning to learn," is the key to efficient learning. It's not just about motivation; it requires careful preparation. In Part 1 of this series, we discussed the first step: Perception. Now, we move on to explore various methods and techniques for efficient learning. However, the key is not to get lost in a sea of information but to pinpoint what works best for you.

Targeted Search for Efficient Learning

Don't blindly search for generic learning techniques. Instead, focus on addressing your specific weaknesses. Employ the 4Fs framework: Identify your flaws and concentrate on improving those areas. For example, if you struggle with note-taking, search for effective note-taking methods tailored to your needs. This targeted approach ensures efficiency in your learning process.

2. Finding Your Motivation: The Fuel for Learning

Motivation is the catalyst for action. While discipline is crucial for building habits, motivation is equally essential. It's the ignition needed to start your learning journey. But motivation isn't a mystical force; you can create it by finding purpose in what you do.

Creating Your Motivation Through Purpose

When you're faced with a daunting task like studying for a challenging deadline, finding motivation can be tough. Take a moment to reflect on why you're doing it. Consider the benefits and rewards you'll reap from your efforts. By creating purpose, you can reignite your motivation and drive your actions.

3. Active Participation: Learning in the Real World

Active participation in events like hackathons and competitions is a powerful way to accelerate your learning. It thrusts you out of your comfort zone and exposes you to real-world pressures.

The Power of Active Participation

Participating actively forces you to adapt and learn quickly. When you're under pressure, you absorb knowledge rapidly. It provides a clear objective and path forward. For instance, if you're struggling with learning a specific skill, seek out related events or challenges. Active participation not only broadens your skill set but also sharpens your focus.

Conclusion

Thank you for joining us in the second part of this series. If you found this blog helpful, please leave a like or reaction. Your feedback is valuable and will aid in improving future content.

Learning Anything 10x Faster

Kairus Noah Tecson — Mon, 28 Aug 2023 03:42:33 +0000

Purpose

Create a strong foundation in learning which also is the foundation of every success. The purpose of this article is to show you an effective way of learning in a short amount of time or being time effective. This can be applied to every aspects of career, can be software engineering, data sciences, data engineering, etc. since learning is a general aspect to everyone and being efficient in this thing makes you already ahead of the majority.

This is mostly based on my personal experience. Being able to learn new field or topic (ex. Marketing or Business) in a short amount of time. I've seen this most effective in hackathons since I have applied all of this techniques and mentality throughout my competitions that made me win some.

Check out Part 2 of this blog series

This is a series-based article. I will be posting my blogs everyday, featuring 3 effective ways on improving your learning process. Follow me to be updated with my release blogs.

Article No Longer Available

Preface

I started as not knowing development at or any other thing other than basic syntaxes of programming. It has been almost 1 year ago (September 29) and during that time did I start having a goal to improve in the field of development.

During an almost a year duration of grinding of learning or ultralearning, I have achieved quite a lot yet unexpected feats. I have been a Champion in a regional programming competition that involves more than 20+ universities offering Computer Science and Information Technology courses. I also participated on other regional programming competitions and hackathons. I recently achieved 2nd runner up in a hackathon which is held by one of the most prestige universities in my country. 2nd runner up might be quite low achievement but I achieved it alone against different teams composed of more than 3. I also obtained skills in fullstack development. ReactJS, ExpressJS, Github Actions, Ionic, Github and Git, other templating languages, etc.

Let me share this to you on how I achieved such boost of skills in just less than a year and may somehow find this as an essential weapon in your arsenal in the future.

Methods

1. Perception of Learning

Perception is a lens. This is how you view the world. This is pertained as the most root of all. If you want to change your character, start with your perception. If your character change, so does your thought. If your thought change, so does your actions.

Perception is the most fundamental of all. If you want to be the most efficient learner, you must start on how you view learning.

Learning is the acquisition of knowledge or skills through experience, study, or by being taught.

You must view learning as a step for you to reach your goal and not as a step towards social entitlement of being a nerd. Learning is fundamental in every personal growth. You might see someone in your class excelling that hard in class. It does not came from talent but from learning. Knowledge does not just comes popping out your brain, it is learned. The same goes by with other geniuses in this world, they all started in learning. It only starts to differ on how much time and effort you are giving on learning.

2. 4Fs: The framework for learning.

There has this term called "Feedback loop" in businesses and startups where they create this "Build-Test-Learn" loop for their products. This helps them hastily develop their product with quality. They create a MVP or a most viable product and test that out immediately, obtaining essential feedbacks for them to implement to their product, which is where "Learn" comes from. This is a continuous loop that spiral upwards towards developing the best out of that product without losing time to market.

The same goes by with personal growth. You yourself is a product for the society, and the same as other product, you must also have a feedback loop. And there is where 4Fs is inspired of. Find Flaws, Fix, and Feedback.

Flaws must not be viewed as a weakness or a defect but an area of opportunity for improvement. Identifying your flaws is an essential on identifying your path for learning. The flaws will be your target and goal for your learning journey. You might find it hard to achieve since you will be addressing face to face what you are lacking. The same goes by with all of us.

Majority of the people are scared to address their own flaws, which is the start of stagnation. Since flaws are not being identified, they don't know that they're already lacking. Being able to identify your flaws is already a great leap since you go beyond the majority.

After you identify or know your areas of improvement, you address it. This is where "Fix" takes place. You address those identified flaws. This is where your learning journey starts. Start off on learning how you can address this flaws and apply those steps you learned as your methods on eliminating those flaws.

You might struggle in public speaking, you identify it as one of your flaws. You may be tempted to search ways on how to improve your public speaking immediately, but that must no be your first step. As I discussed in my first method for efficient learning, perception is the most fundamental of everything. Thus, you must fix your perception on that flaw first, public speaking. You learned that your perception on public speaking as something your are not fit in since you are an introvert. You then address this perception first: that public speaking is not only for extrovert but more of a mode of communicating your knowledge or research to your audience. You think beyond yourself and find purpose on creating value for others. You then move forward on other techniques or methods on fixing and improving your flaws. This can be searching on Youtube for public speaking tips.

Last one is the most important of all, Feedback. After you spent efforts honing your craft, addressing those flaws, test your self. This can be through having practicing your public speaking to your friends or family. Your goal is not for them to praise you but to gather their feedback. Know their insights, then you can identify again your flaws. Praise and recognition is just a plus, what you wanted is identifying flaws that is already beyond your own recognition. Then you can start looping again on identifying your flaws and fixing it.

This loop is a continuous process of improvement. Just like a ball, without having to take action continuously, you cannot move, you become stagnant. Potential energy cannot move on its own, it must be on your own intervention, your own action can it start to move. Just like your own potential, you own flaws, you cannot fix and improve your craft if you will not take action.

3. Just do it

Just like the meme says, Just do it. Beyond the meme, It have been a part of my motivation before I learn to address my perception first. But this phrase still stays relevant.
One of the most hardest, most energy consuming in a rocket launch towards space is the take off. It takes so much energy to resist the pull of gravity just to be able to go out its range of reach.

Our own life also has its own gravity. Just waking up in the morning, you are already suppressed by your own gravity's force to sleep again or just stay laying on your bed. It takes so much effort just to resist the gravity to start doing things you must do. This is where "Just do it" phrase comes in. Not thinking about anything else, just your motivation and reason to take action at the same time the burst of action itself is what will get you to take off. Once you start taking off, start learning, start building habits, start addressing those flaws, then will it be more easier to go in the flow.

End

This is my first time writing about personal development stuffs, blogging in general, and mostly just write in my learning journal. If you've liked this and found this helpful, please send your support through likes and comments. Comment down your own feedback about my content.

Server vs. Serverless Computing: Benefits and Downsides

Kairus Noah Tecson — Wed, 19 Apr 2023 05:33:24 +0000

👋 Introduction

In today's fast-paced world, companies of all sizes are searching for ways to optimize their web application's performance and reduce costs. Two of the most popular computing models are server and serverless computing. Both server and serverless computing have benefits and downsides that should be carefully considered before selecting the appropriate option.

In this article, we will provide an overview of server and serverless computing and discuss their benefits and downsides. We will also answer some frequently asked questions about server and serverless computing.

🖥️ What is Server Computing?

In server computing, a server or a group of servers is responsible for managing the application's requests and resources. The servers are responsible for running the application's code, storing data, and handling security.

In short, it's the business owners that handles the server of their application. From maintenance up to to running the server in their own built servers.

👨‍💻 What is Serverless Computing?

Despite the name "Serverless", it does not mean it does not have a server

Serverless computing is a cloud-based model where a third-party provider manages the application's resources. In serverless computing, the provider handles the servers, operating systems, and infrastructure.

This means that you don't need to run and host your own server in your own built computer. This means that you can continually scale your application without minding about the maintenance and security of it.

🤔 What are the Benefits and Downsides of Server and Serverless Computing?

In this section, we will compare the benefits and downsides of both server and serverless computing

💪 Benefits of Server Computing

Full Control: Companies have full control over the server's hardware, software, and network settings.
Customization: Companies can customize the server settings based on their requirements.
Predictable Cost: Companies can predict the cost of their servers since they are responsible for managing them.
Monitoring: Companies can monitor their servers and fix any issues in real-time.

👎 Downsides of Server Computing

Maintenance: Companies must maintain their servers, which can be a time-consuming and costly process.
Scalability: Scalability can be challenging since companies need to add more servers as the application grows.
Upfront Costs: Companies need to invest upfront in server hardware and software.

💪 Benefits of Serverless Computing

Cost-Effectiveness: Companies only pay for the resources they use, making serverless computing more cost-effective.
Scalability: Serverless computing is highly scalable, and companies do not need to worry about adding more resources as the application grows.
Fast Deployment: Deployment times are faster since companies do not need to manage infrastructure.
Automatic Updates: Third-party providers handle server maintenance and updates.

👎 Downsides of Serverless Computing

Lack of Control: Companies do not have control over the infrastructure, making it difficult to customize the server settings

The '...' operator and common uses - Ellipsis or the yada yada yada operator

Kairus Noah Tecson — Mon, 10 Apr 2023 03:51:00 +0000

You may have encountered this '…' syntax in some code or in a Youtube tutorial and just don't know how this small three dot syntax is important in executing the code properly.

Missing one dot and there does the red line beneath it…

That three dot you might be encountering is an Ellipsis operator. Other name for it is the 'triple dot' operator or the 'yada yada yada' operator. You might see this a lot even in different programming languages.

You might even question if this is just some naming convention or some placeholder. Might be true, but this operator comes in a lot more different functionalities which might depend on the programming language and the context it has been used.

But today we will be showing and explain some common uses of this operator for you to use in your coding arsenal.

1. Rest Parameter

In Javascript, the ellipsis can be used to represent a rest parameter, which allows a function to accept an arbitrary number of arguments as an array. As an example

function myFunction(...args) {
  console.log(args); // Output: [1, 2, 3, 4, 5]
}

myFunction(1, 2, 3, 4, 5);

This take on the argument (1, 2, 3, 4, 5) and store it inside the args parameter which is declared as an array. In short, you're stating that the parameter is an array with the use of the ellipsis operator. Even if you passed in an argument of one element, the result will still be inside an array.

2. Spread Syntax

This is applied again in Javascript but in different context. The ellipsis operator can be used to spread elements of an array/object into a new array/object. For example.

const arr = [1,2,3] 
const newObject = [...arr, 2, 4]
console.log(newObject)   
// output = [1, 2, 3, 2, 4]

Note that you can only store this the result of the ellipsis operator inside another object/array.

const arr = [1,2,3]
const string = ...arr

If you store this spread array other than object/array, this will result to an error.

const arr = [1,2,3]
const string = [...arr]

This is the correct way for this which will result as an object type.

console.log(typeof(string)) -> object

3. Variadic Templates

Let's go outside and Javascript and go for more low level language, C++. The ellipsis in C++ can be used to define a variadic template. This variadic template, which is a feature in C++, allows a function/class to accept a arbitrary number of arguments of different types. For example:

template<typename... Args>

void print(Args... args) {
    ((cout << args << " "), ...);
}
void main() {
    print(1, 2, "hello world", true)
    // return -> 1 2 hello world 1
    // true = 1
}

This is like in the number 1, Rest Parameters, which is in Javascript but in more complex way because it can take different data types as an argument and can be output one by one using again the ellipsis operator with the syntax of ((args), ...);
This makes C++ a more lot flexible through having dynamic size of memory being allocated.

4. Placeholder for unused parameters

Lastly in Python, the ellipsis can be used as a placeholder for unused function or method parameters. For example:

def sample(a, b, x):
    print(a + b)
sample(1, 2, ...)

This can be placed as an argument for any parameter only if it is not used within the function. This can be useful if you don't have certain value to put for the parameter and you just wanted to execute and test out the function.

Conclusion

There can be a lot more different functionalities of ellipsis mostly in other programming languages. This is just for some most common uses of the operator in commonly used programming languages. But there you go, you can now use this operator in your arsenal. This is incredibly useful in terms of handling database query responses.