DEV Community: Tino Joel Muchenje

OpenAI Drops o3 Pricing by 80% — and Launches o3-pro for Tougher Problems

Tino Joel Muchenje — Wed, 11 Jun 2025 07:57:52 +0000

Just got an email from OpenAI, and it's a big one for developers, especially those building AI apps at scale.

💸 o3 Is Now 80% Cheaper!
OpenAI has dropped the price of the o3 model to:

$2 / 1M input tokens

$8 / 1M output tokens

This isn’t a stripped-down version — it’s the same o3 model, just cheaper thanks to inference stack optimizations.

👨‍💻 Why You Should Try o3 Now
OpenAI recommends using o3 for:

Coding tasks (same price per token as GPT-4.1, cheaper than GPT-4o)

Agentic tool calling

Function calling

Instruction following

If you're building apps with tool use, structured tasks, or agents — o3 is now way more cost-effective.

🔍 Introducing: o3-pro
For devs dealing with more complex reasoning or production use cases, OpenAI just launched o3-pro — a version of o3 that uses more compute to give deeper, more reliable responses.

o3-pro Pricing:
$20 / 1M input tokens

$80 / 1M output tokens
💰 That’s 87% cheaper than the old o1-pro model.

Supported Features:
Image inputs

Function calling

Structured Outputs

Background mode for long-running requests

🧠 o3-pro is better suited for difficult problems that need extra computation time and accuracy.

📌 TL;DR for Devs
Use o3 for general-purpose and coding tasks → super cheap now.

Use o3-pro when you need reliability, depth, and complex logic.

Test o3-pro-2025-06-10 in the Responses API or Playground.

Long requests? Try the new background mode to avoid timeouts.

🧪 These pricing changes make it way more feasible to build powerful AI experiences without blowing your budget.

Let the tinkering begin. 🚀

Have you tried the new o3 or o3-pro yet? Share your results or thoughts below!

OpenAI #LLM #API #DevTools #AI #GPT #MachineLearning #Coding #FunctionCalling #DeveloperExperience

Have more visibility in your APIs!

Tino Joel Muchenje — Tue, 13 May 2025 06:24:40 +0000

Tino Joel Muchenje

May 8 '25

Building a Comprehensive Observability Stack for a .NET API with Core Banking Integration

#programming #backenddevelopment #banking #api

Comments 1

3 min read

Building a Comprehensive Observability Stack for a .NET API with Core Banking Integration

Tino Joel Muchenje — Thu, 08 May 2025 19:36:39 +0000

Introduction

In this article, I'll walk you through how I implemented a complete observability solution for a .NET 8 minimal API that integrates with a core banking system. I'll cover the architecture decisions, implementation process, challenges faced, and the final result that provides comprehensive monitoring capabilities.

The Challenge

My .NET API needed to reliably interface with a core banking system through SOAP services while providing comprehensive monitoring capabilities. The initial codebase had limited observability features, making it difficult to:

Track performance issues
Monitor service health
Trace requests across system boundaries
Identify and diagnose errors quickly

The Solution Architecture

I implemented a complete observability stack consisting of:

Structured Logging with Serilog
Distributed Tracing with OpenTelemetry and Jaeger
Metrics Collection with Prometheus
Visualization with Grafana
Health Checks for the API and its dependencies

The architecture looks like this:

┌───────────────────┐     ┌───────────────┐     ┌─────────────┐
│ .NET API          │────►│ Prometheus    │────►│ Grafana     │
│ - Metrics endpoint│     │ (Metrics DB)  │     │ (Dashboards)│
│ - Health checks   │     └───────────────┘     └─────────────┘
│ - OpenTelemetry   │     
│ - Serilog         │     ┌───────────────┐     
└───────┬───────────┘────►│ Jaeger       │     
        │                 │ (Tracing)    │     
        │                 └───────────────┘     
        │                 
        │                 ┌───────────────┐     
        └────────────────►│ Seq          │     
                          │ (Logs)       │     
                          └───────────────┘

Implementation Steps

1. Setting Up Structured Logging

I implemented Serilog for structured logging with multiple sinks:

builder.Host.UseSerilog((context, configuration) => 
    configuration
        .ReadFrom.Configuration(context.Configuration)
        .Enrich.FromLogContext()
        .Enrich.WithMachineName()
        .Enrich.WithCorrelationId()
        .WriteTo.Console()
        .WriteTo.Seq("http://localhost:5342")
        .WriteTo.File("logs/log-.txt", rollingInterval: RollingInterval.Day));

2. Adding OpenTelemetry for Distributed Tracing

I integrated OpenTelemetry with Jaeger for distributed tracing:

builder.Services.AddOpenTelemetry()
    .WithTracing(tracing => tracing
        .AddAspNetCoreInstrumentation()
        .AddHttpClientInstrumentation()
        .AddSource("BankingService")
        .AddOtlpExporter(options => options.Endpoint = new Uri("http://localhost:4317")));

This configuration sends trace data to Jaeger, where I can visualize complete request flows and identify performance bottlenecks across service boundaries.

3. Configuring Metrics Collection

For metrics, I initially tried OpenTelemetry.Exporter.Prometheus.AspNetCore but switched to prometheus-net due to stability issues:

builder.Services.AddSingleton<IMetricsRegistry, MetricsRegistry>();
// Prometheus metrics endpoint
app.UseMetricServer();

4. Implementing Health Checks

I added comprehensive health checks:

builder.Services.AddHealthChecks()
    .AddCheck("API", () => HealthCheckResult.Healthy())
    .AddCheck<BankingServiceHealthCheck>("BankingService", tags: new[] { "services" });

5. Docker Compose for Observability Infrastructure

I created a dedicated docker-compose file for the observability stack:

version: '3.8'

services:
  prometheus:
    image: prom/prometheus
    volumes:
      - ./prometheus:/etc/prometheus
    ports:
      - "9090:9090"

  grafana:
    image: grafana/grafana
    volumes:
      - ./grafana/provisioning:/etc/grafana/provisioning
      - ./grafana/dashboards:/var/lib/grafana/dashboards
    ports:
      - "3001:3000"

  jaeger:
    image: jaegertracing/all-in-one
    ports:
      - "16686:16686"
      - "4317:4317"

  seq:
    image: datalust/seq
    ports:
      - "5341:80"
      - "5342:5341"

Challenges Encountered

1. Prometheus Integration Issues

The OpenTelemetry.Exporter.Prometheus.AspNetCore package lacked a stable release. I switched to prometheus-net, which required refactoring my metrics collection approach but provided better stability.

2. Docker Networking Problems

Initially, Prometheus couldn't scrape my API metrics. The issue was in the Prometheus configuration, which needed to use host.docker.internal:5071 to access the API running on the host:

scrape_configs:
  - job_name: 'banking-integration'
    scrape_interval: 5s
    static_configs:
      - targets: ['host.docker.internal:5071']

3. Port Conflicts

I encountered port conflicts with Grafana's default port (3000). The solution was simple - changing it to 3001 in my docker-compose configuration.

The Final Result

My observability solution provides comprehensive monitoring capabilities:

Structured logs viewable in Seq with full context and correlation IDs
Distributed traces visualized in Jaeger showing complete request flows
Custom metrics dashboards in Grafana displaying:
- API health status
- HTTP request rates and status codes
- Request durations
- Banking service performance metrics
- Error rates
- Resource usage

Key Learnings

Start with health checks - They're the foundation of observability and help define what "healthy" means for your service.
Plan for correlations - Ensure correlation IDs flow through logs, traces, and metrics for effective troubleshooting.
Jaeger is invaluable for complex systems - Distributed tracing with Jaeger provides insights that logs and metrics alone cannot offer, especially for understanding request flows across service boundaries.
Use Docker Compose for local development - Makes it easy to spin up complex observability infrastructure locally.
Custom metrics matter - Generic metrics are helpful, but domain-specific metrics provide the most valuable insights.

Conclusion

Implementing a comprehensive observability solution for my .NET API has significantly improved my ability to monitor, diagnose, and optimize the core banking integration service. The combination of structured logging, distributed tracing with Jaeger, and metrics collection provides a complete picture of system behavior.

The most significant benefit is the reduced time to identify and resolve issues - what previously might have taken hours of debugging can now be spotted in minutes through my Grafana dashboards or trace analysis in Jaeger.

What observability tools are you using in your .NET projects? I'd love to hear about your experiences in the comments!

Automating Docker Deployments to Azure with GitHub Actions: A Step-by-Step Guide

Tino Joel Muchenje — Thu, 12 Sep 2024 12:41:51 +0000

Automating Docker Deployments to Azure with GitHub Actions: A Step-by-Step Guide

In this article, we'll walk through how to automate your container deployment process using Azure Container Registry (ACR) and Azure Container Instances (ACI), all triggered from GitHub Actions. You’ll learn how to set up your resources, link them with GitHub, and automate deployments in a way that can fit right into your workflow.

Why Should You Care?

Imagine you’ve just finished building a cool app or service, and now you need to deploy it somewhere. You don’t want to manually build Docker images, push them to a registry, and then manually deploy them every time you make a change. Automating this process saves time and reduces the risk of mistakes!

What We'll Cover:

Prerequisites
Setting Up Azure Resources
Creating an Azure Service Principal
GitHub Secrets and Workflows
How the Automation Works
Running It Yourself
Helpful Tips and Troubleshooting

Let’s dive in!

1. Prerequisites

Before you get started, make sure you have:

An Azure account with an active subscription.
A GitHub account.
The Azure CLI and Docker installed locally.

Tools we'll be using:

Azure CLI: This is your command-line interface for managing Azure resources.
Docker: You’ll need this to build your application images.
GitHub Actions: This will automate your deployment pipeline.

Terms to know

ACR - Azure container registry

ACI - Azure container instances

2. Setting Up Azure Resources

First, we need to create a resource group and a container registry in Azure to store our Docker images.

Create a Resource Group: Think of a resource group as a folder where you organize your Azure resources.

   az group create --name <your-resource-group> --location <location>

Create Azure Container Registry (ACR): This is where your Docker images will be stored.

   az acr create --resource-group <your-resource-group> --name <your-registry-name> --sku Basic

3. Creating an Azure Service Principal

To allow GitHub Actions to access Azure resources, we’ll create something called a Service Principal. It’s like giving GitHub a key to open the door to your Azure account.

Run this command to create the service principal:

   az ad sp create-for-rbac --name "GitHubAction" --role contributor \
   --scopes /subscriptions/<subscription-id>/resourceGroups/<your-resource-group>/providers/Microsoft.ContainerRegistry/registries/<your-registry-name> \
   --sdk-auth

Save the JSON output from this command. We’ll use it later in GitHub as a secret to authenticate.

4. GitHub Secrets and Workflows

4.1 Add Secrets to GitHub

In your GitHub repository:

Go to Settings > Secrets and variables > Actions.
Add the following secrets:
- AZURE_CREDENTIALS: Paste the JSON output from the Service Principal.
- REGISTRY_LOGIN_SERVER: Your Azure Container Registry URL (e.g., <your-registry-name>.azurecr.io).
- REGISTRY_USERNAME: The client ID from the service principal JSON.
- REGISTRY_PASSWORD: The client secret from the service principal JSON.

4.2 Create GitHub Workflows

Workflows are the steps that tell GitHub Actions what to do. We’ll create two workflows: one to build and push your Docker image to ACR, and another to deploy the image to ACI.

ACR Build and Push Workflow:

This workflow will build your Docker image and push it to ACR every time you push code to the main branch.

name: Build and Push to ACR

on:
  push:
    branches: [ main ]

jobs:
  build-and-push:
    runs-on: ubuntu-latest

    steps:
      - uses: actions/checkout@v2

      - name: 'Login to Azure'
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: 'Build and push image'
        run: |
          docker build . -t ${{ secrets.REGISTRY_LOGIN_SERVER }}/app:latest
          docker push ${{ secrets.REGISTRY_LOGIN_SERVER }}/app:latest

ACI Deployment Workflow:

This workflow will deploy your container to Azure when you trigger it manually.

name: Deploy to ACI

on:
  workflow_dispatch:

jobs:
  deploy:
    runs-on: ubuntu-latest

    steps:
      - name: 'Login to Azure'
        uses: azure/login@v1
        with:
          creds: ${{ secrets.AZURE_CREDENTIALS }}

      - name: 'Deploy to Azure Container Instances'
        uses: 'azure/aci-deploy@v1'
        with:
          resource-group: <your-resource-group>
          dns-name-label: myappdeployment
          image: ${{ secrets.REGISTRY_LOGIN_SERVER }}/app:latest
          location: 'eastus'
          cpu: 1
          memory: 1.5
          ports: 80

5. How the Automation Works

ACR Build and Push Workflow:
- Triggered when you push code to the main branch.
- Logs into Azure, builds the Docker image, and pushes it to the registry.
ACI Deployment Workflow:
- Manually triggered.
- Logs into Azure and deploys the Docker image from ACR to ACI.

6. Running It Yourself

Push your code to the main branch, and the build and push workflow will trigger automatically.
To deploy, go to the GitHub Actions tab and manually trigger the ACI deployment workflow.

7. Helpful Tips and Troubleshooting

Keep Secrets Safe: Make sure your GitHub secrets are correctly set up. If something isn’t working, it’s often an issue with secrets.
Double-Check Logs: If the deployment fails, check the logs in the Azure portal or in the GitHub Actions logs for more detailed error messages.
Manage Docker Images: Over time, you may want to delete old Docker images from ACR to save space.

Conclusion

With just a few steps, you can automate your Docker deployments to Azure, saving time and avoiding manual mistakes. By using GitHub Actions and Azure services together, you’re taking a big step toward a more efficient and reliable workflow!

Feel free to share any questions or tips in the comments below!

Getting Started with AI for Developers: Part 1 - Demystifying the Basics

Tino Joel Muchenje — Mon, 09 Sep 2024 07:25:13 +0000

Hello, Developers!

AI is no longer just a dream. It's here and changing how we build software. It can make apps better and more useful. But how do you start using AI in your projects?

This series aims to equip you with the fundamental knowledge to embark on your AI development journey. In this first part, we'll delve into core concepts and provide a hands-on example using Langchain and OpenAI.

Demystifying AI Jargon:

Before diving in, let's clear the air with some key terms:

LLM (Large Language Model): These advanced AI models are trained on massive datasets of text and code, enabling them to generate human-quality text, translate languages, write different kinds of creative content, and answer your questions in an informative way. Thats OpenAi, Gemni, Claude, Llama etc

Langchain: This innovative library simplifies the process of interacting with various AI services through a unified API. It acts as a bridge between your code and powerful AI platforms like OpenAI.

Different Types of AI Models:

There are numerous types of AI models, each specializing in a specific task. Some common categories include:

Classification models: Used to categorize data points, such as spam detection or image recognition.
Generative models: Create new data, like generating realistic images or composing music.
Regression models: Predict continuous values based on input data, used in forecasting or trend analysis.
Understanding the different model types helps you choose the right tool for the job.

Hands-on Example: Chatting with OpenAI using Langchain

Now, let's get our hands dirty! This code snippet demonstrates how to interact with OpenAI's chatbot functionality using Langchain:

import { ChatOpenAI } from "@langchain/openai";

async function main() {
  const chatModel = new ChatOpenAI({}); // Create a ChatOpenAI instance

  const response = await chatModel.invoke("What is Hello World?"); // Ask a question
  console.log(response); // Print the response
}

main().catch(console.error);

Refer to https://github.com/Tinomuchenje/ai-dev-journey.git for running setup example.

Explanation

1. This code first imports the necessary module, ChatOpenAI, from the @langchain/openai package
Then, it creates an instance of ChatOpenAI. The invoke method allows us to send a question ("What is Hello World?") to the OpenAI chatbot and capture its response.
Finally, the response is logged to the console.

Make sure you have Langchain and its dependencies installed before running this code. You can find instructions on the Langchain website: https://js.langchain.com/v0.2/docs/introduction/

Additionally, you'll need an OpenAI API key to use the service. Refer to OpenAI's documentation for acquiring one.

This is just a taste of what's possible with Langchain and AI. In the upcoming parts of this series, we'll explore more complex applications, delve into different AI models, and equip you with the skills to build your own AI-powered projects.

Stay tuned for Part 2!

Further Resources:

Langchain Documentation: https://js.langchain.com/v0.2/docs/introduction/

This article serves as a springboard for your AI development journey. Feel free to tinker with the code and experiment with different functionalities. With dedication and a thirst for exploration, you'll be building your own AI marvels in no time!

Happy coding

Careful using forEach in Javascript

Tino Joel Muchenje — Fri, 03 Nov 2023 08:20:56 +0000

When dealing with asynchronous functions, using Array.prototype.forEach() can lead to unexpected behavior. Let’s explore why and discuss alternative approaches.

Array.prototype.forEach() and Asynchronous Functions:

The forEach() method is commonly used for iterating through arrays. However, it has a limitation: it does not work well with asynchronous functions.
When you use forEach() with asynchronous operations (such as promises), it does not wait for the promises to resolve. As a result, the calculations inside the promises may be lost, leading to incorrect results or errors.

Example

const ratings = [5, 4, 5];
let sum = 0;

const sumFunction = async (a, b) => a + b;

ratings.forEach(async (rating) => {
  sum = await sumFunction(sum, rating);
});

console.log(sum);
// Naively expected output: 14
// Actual output: 0

In the sumFunction is asynchronous, but the forEach() loop does not wait for the promises to complete. Hence, the actual output is 0, even though you would naively expected it to be 14.

2. Alternative Approach: Using for...of:

Instead of forEach(), consider using a for...of loop. This loop does await each asynchronous task in order, ensuring that promises are resolved before moving to the next iteration.
Here’s how you can rewrite your example using for...of:

Example

const ratings = [5, 4, 5];
let sum = 0;

const sumFunction = async (a, b) => a + b;

for (const rating of ratings) {
  sum = await sumFunction(sum, rating);
}

console.log(sum); // Expected output: 14

3. Best Practices:

While for...of is a better choice for handling asynchronous tasks, it’s essential to understand the behavior of different iteration methods.
Be aware of conventions and project-specific guidelines. Discuss with your team to find the solution that best suits your project’s needs.

Remember, using the right iteration method can significantly impact the correctness and performance of your code.

Happy coding! 🚀🔍👩‍💻

References

How to use Ruby on Rails ActiveRecord joins

Tino Joel Muchenje — Tue, 04 Jul 2023 14:11:14 +0000

In this article, I will show you how to use the ActiveRecord joins method to query data from two or more tables in Ruby on Rails. I will use a simple example of a SsoProfile model that belongs to a User model and has some attributes related to a single sign-on provider.

What is a join?
A join is a way of combining two or more tables based on a common attribute. For example, in this case, the SsoProfile table and the User table have a common attribute called user_id, which is the foreign key that references the User table. A join allows you to access the data from both tables in one query, by matching the rows that have the same user_id value.

How to use joins in Rails?
Rails provides a built-in method called joins that takes an argument of the name of the association or a hash of associations. For example, if you have a SsoProfile model that belongs to a User model, you can use joins like this:

Find all SsoProfiles by joining the users table

sso_profiles = SsoProfile.joins(:user)

Find a SsoProfile by joining the users table and using the email attribute

sso_profile = SsoProfile.joins(:user).find_by(users: {email: "alice@gmail.com"})

The joins method will return an ActiveRecord::Relation object that you can chain with other methods like where, order, limit, etc.

How to illustrate a join?
To illustrate how a join works, let's look at an example of how the SsoProfile table and the User table would look:

SsoProfile table	user_id	sso_provider	sso_provider_id	sso_provider_data
1	1	google	1234567890	{"name": "Alice", "email": "alice@gmail.com", "picture": "https://example.com/alice.jpg"}
2	2	facebook	9876543210	{"name": "Bob", "email": "bob@facebook.com", "picture": "https://example.com/bob.jpg"}
3	3	twitter	4567891230	{"name": "Charlie", "email": "charlie@twitter.com", "picture": "https://example.com/charlie.jpg"}

User table	id	email	name
1	1	alice@gmail.com	Alice
2	2	bob@facebook.com	Bob
3	3	charlie@twitter.com	Charlie

A join will combine the two tables based on the user_id attribute, like this:

SsoProfile table JOIN User table on user_id = id
user_id sso_provider sso_provider_id sso_provider_data id email name
1 google 1234567890 {"name": "Alice", ...} 1 alice@gmail.com Alice
2 facebook 9876543210 {"name": "Bob", ...} 2 bob@facebook.com Bob
3 twitter 4567891230 {"name": "Charlie", ...} 3 charlie@twitter.com Charlie

You can see that the join has matched the rows that have the same user_id value and created a new table with all the attributes from both tables. You can use this new table to query the data from both tables in one query, by using the table name and the attribute name.

# Understanding .NET 6 Configuration Files

Tino Joel Muchenje — Tue, 04 Jul 2023 14:07:39 +0000

Configuring a .NET 6 application can be a complex task, especially when dealing with different environments, sensitive data, and file paths. This article will guide you through the key aspects of understanding and using the appsettings.json file in a .NET 6 application.

Understanding the `appsettings.json` File

The appsettings.json file is a critical part of a .NET application. It is primarily used for storing application settings, such as connection strings, logging settings, and other configuration data.

Here's an example of what a typical appsettings.json file could look like:

{
  "Logging": {
    "LogLevel": {
      "Default": "Debug",
      "System": "Information",
      "Microsoft": "Error"
    }
  },
  "AllowedHosts": "*",
  "ConnectionString": "Data Source=Database;Initial Catalog=AppDB;Integrated Security=True",
  "NetworkPath": "\\\\ServerName\\SharedFolder"
}

Handling Sensitive Data in Configuration

One of the key considerations when dealing with configuration files is the handling of sensitive data. It is never recommended to store sensitive data, like database connection strings, in the configuration file in plain text. Instead, consider using the Secret Manager tool or environment variables to store sensitive data.

Network Paths in Configuration

When defining a network path in the appsettings.json file, you can simply provide the network path as a string value. However, your application will need appropriate permissions to access the network path. If it's running under a user account that has access to the network path, it should be able to read the path without issues.

Here's an example of how to define a network path:

{
  "NetworkPath": "\\\\ServerName\\SharedFolder"
}

In .NET, the double backslashes (\\\\) will be interpreted as a single backslash (\). This is because the backslash is an escape character in C#, which means it is used to introduce special character sequences.

Accessing Configuration Values

To access these configuration values in your .NET 6 app, you can use the IConfiguration interface. Here's an example:

public class Startup
{
    private readonly IConfiguration _configuration;

    public Startup(IConfiguration configuration)
    {
        _configuration = configuration;
    }

    public void ConfigureServices(IServiceCollection services)
    {
        var networkPath = _configuration["NetworkPath"];
        // Use networkPath...
    }
}

Conclusion

The appsettings.json file is a key component of .NET 6 applications, allowing developers to manage various configurations. By understanding how to properly structure this file, manage sensitive data, define network paths, and access configuration values in the code, you can create more secure and flexible .NET applications. Remember that the final configuration values will be a combination of various sources like environment variables, command line arguments, and user secrets. Always ensure that your application has the necessary permissions to access any paths defined in the configuration.

Happy Coding!

Learn about the difference between var, let, and const keywords in JavaScript and when to use them.

Tino Joel Muchenje — Fri, 02 Jun 2023 10:21:01 +0000

var, let, and const: What's the Difference in JavaScript?

JavaScript is a dynamic and flexible language that allows you to declare variables in different ways. You can use var, let, or const keywords to declare variables in JavaScript, but what's the difference between them and when should you use them?

In this article, you will learn about the difference between var, let, and const keywords in JavaScript and some of their advantages and disadvantages.

What is a variable?

A variable is a container for storing information. You can use a variable to store a value, such as a number, a string, a boolean, an object, or a function. You can also use a variable to refer to a value that may change over time.

To declare a variable in JavaScript, you need to use a keyword followed by a name for the variable. For example:

var x = 10; // Declare a variable using var
let y = 20; // Declare a variable using let
const z = 30; // Declare a variable using const

The name of the variable must follow some rules:

• It must begin with a letter, or $, or _.

• It cannot contain spaces or punctuation marks (except $ and _).

• It cannot be a reserved word in JavaScript, such as var, let, const, if, for, etc.

• It is case sensitive, meaning that x and X are different variables.

What is the difference between var, let, and const?

The main difference between var, let, and const is how they affect the scope and hoisting of the variables.

Scope
The scope of a variable is the part of the code where the variable can be accessed or used. In JavaScript, there are two types of scopes: global scope and local scope.

• Global scope: A variable declared in the global scope can be accessed from anywhere in the code. A variable declared outside any function or block is in the global scope.

• Local scope: A variable declared in the local scope can only be accessed within the function or block where it is declared. A variable declared inside a function or block is in the local scope.

The scope of a variable declared with var is either global or function-based. This means that if you declare a variable with var inside a function, it can only be accessed within that function. However, if you declare a variable with var inside a block (such as an if statement or a for loop), it can be accessed outside that block as well.

For example:

function foo() {
var x = 10; // Declare x with var inside foo function
if (true) {
var y = 20; // Declare y with var inside if block
console.log(x); // 10 (x is accessible inside if block)
console.log(y); // 20 (y is accessible inside if block)
}
console.log(x); // 10 (x is accessible outside if block)
console.log(y); // 20 (y is accessible outside if block)
}

foo();

console.log(x); // ReferenceError: x is not defined (x is not accessible outside foo function)
console.log(y); // ReferenceError: y is not defined (y is not accessible outside foo function)

The scope of a variable declared with let or const is block-based. This means that if you declare a variable with let or const inside any block (such as a function, an if statement, or a for loop), it can only be accessed within that block.

For example:

function foo() {
let x = 10; // Declare x with let inside foo function
const z = 30; // Declare z with const inside foo function
if (true) {
let y = 20; // Declare y with let inside if block
console.log(x); // 10 (x is accessible inside if block)
console.log(y); // 20 (y is accessible inside if block)
console.log(z); // 30 (z is accessible inside if block)
}
console.log(x); // 10 (x is accessible outside if block)
console.log(y); // ReferenceError: y is not defined (y is not accessible outside if block)
console.log(z); // 30 (z is accessible outside if block)
}

foo();

console.log(x); // ReferenceError: x is not defined (x is not accessible outside foo function)
console.log(y); // ReferenceError: y is not defined (y is not accessible outside foo function)
console.log(z); // ReferenceError: z is not defined (z is not accessible outside foo function)

Using block-based scope can prevent accidental leaks and conflicts of variables with the same name in different blocks.

Hoisting
Hoisting is a mechanism in JavaScript that moves the declarations of variables to the top of their scope before any code is executed. This means that you can use a variable before it is declared, but its initial value will be undefined.

Hoisting applies differently to variables declared with var, let, and const.

Variables declared with var are hoisted to the top of their scope, either global or function-based. This means that you can use them before they are declared, but their initial value will be undefined.

For example:

console.log(x); // undefined (x is hoisted but not initialized)
var x = 10;
console.log(x); // 10

Variables declared with let or const are also hoisted to the top of their scope, but they are not initialized until they are declared. This means that you cannot use them before they are declared, and you will get a reference error.

For example:

console.log(x); // ReferenceError: Cannot access 'x' before initialization (x is hoisted but not initialized)
let x = 10;
console.log(x); // 10

console.log(y); // ReferenceError: Cannot access 'y' before initialization (y is hoisted but not initialized)
const y = 20;
console.log(y); // 20

This behavior creates a temporal dead zone between the hoisting and the initialization of the variables declared with let or const. This can prevent errors and enforce good coding practices.

When to use var, let, and const?
As you have seen, there are some advantages and disadvantages of using var, let, and const to declare variables in JavaScript. So when should you use them?

The general recommendation is to avoid using var unless you have a specific reason to do so. Using var can cause confusion and errors due to its function-based scope and hoisting behavior.

Instead, you should use let or const to declare variables with block-based scope and temporal dead zone. This can prevent accidental leaks and conflicts of variables with different blocks.

The main difference between let and const is that let allows you to change the value of a variable after it is declared, while const does not. You should use const when you want to declare a constant value that will not change, such as:

• A primitive value like a number or a string.

• A reference to an object or an array that will always point to the same object or array.

• A function expression or an arrow function.

You should use let when you want to declare a variable that may change over time, such as:

• A counter or an iterator in a loop.

• A temporary value in an algorithm.

• A conditionally assigned value in an if-else statement.

Here are some examples of using let and const:

// Use const for primitive values that will not change
const PI = 3.14;
const NAME = "John";

// Use const for references to objects or arrays that will always point to the same object or array
const person = {name: "John", age: 25};
const numbers = [1, 2, 3];

// Use const for function expressions or arrow functions
const add = function(a,b) {
return a + b;
};

const multiply = (a,b) => {
return a * b;
};

// Use let for counters or iterators in loops
for (let i = 0
i < 10; i++) {
console.log(i); // 0, 1, 2, ..., 9
}

// Use let for temporary values in algorithms
let a = 10;
let b = 20;
let temp = a; // Use temp to swap the values of a and b
a = b;
b = temp;

// Use let for conditionally assigned values in if-else statements
let greeting;
if (hour < 12) {
greeting = "Good morning";
} else {
greeting = "Good afternoon";
}

console.log(greeting); // Depends on the value of hour

Conclusion

In this article, you learned about the difference between var, let, and const keywords in JavaScript and when to use them. You learned that:

• var declares a variable with function scope or global scope, and it is hoisted to the top of its scope with an initial value of undefined.

• let and const declare variables with block scope, and they are hoisted to the top of their scope but not initialized until they are declared.

• You should avoid using var unless you have a specific reason to do so, and use let or const instead.

• You should use const when you want to declare a constant value that will not change, and use let when you want to declare a variable that may change over time.

I hope this article helps you understand the difference between var, let, and const in JavaScript. If you have any questions or feedback, please leave a comment below. Thanks for reading!blush

How to find non-numeric values in SQL Server

Tino Joel Muchenje — Mon, 29 May 2023 13:24:46 +0000

Have you ever encountered an error like this when trying to convert a varchar column to a numeric column in SQL Server?

Error converting data type varchar to numeric

This error occurs when the varchar column contains some values that are not valid for the numeric data type, such as alphabets, symbols, spaces, commas, etc.

In this article, I will show you how to find these non-numeric values using some simple SQL queries.

Finding non-numeric values

There are two main ways to find non-numeric values in a varchar column in SQL Server. One way is to use the ISNUMERIC() function, which returns 1 for numeric values and 0 for non-numeric values. Another way is to use the LIKE operator with a pattern that matches any character that is not a digit.

For example, suppose we have a table called Payments with a column called Amount that contains some varchar values. Some of them are numeric, some of them are not. Here is a sample of the data:

Amount
100.00
50.00
75.00
80
90.00
AB
ABCDE#
.ABC

To find the non-numeric values using the ISNUMERIC() function, we can use this query:

Select Amount from Payments where ISNUMERIC(Amount) <> 1

This will return the following rows:

Amount
AB
ABCDE#
.ABC

To find the non-numeric values using the LIKE operator, we can use this query:

Select Amount from Payments where Amount like '%[^0-9]%'

This will return the same rows as before:

Amount
AB
ABCDE#
.ABC

Conclusion

In this article, I have shown you how to find non-numeric values in a varchar column in SQL Server using some simple SQL queries. I hope this helps you understand the cause of the error Error converting data type varchar to numeric and prepare your data for conversion.

If you have any questions or feedback, please let me know in the comments below.

Happy coding!

Parse vs TryParse in C#

Tino Joel Muchenje — Wed, 24 May 2023 09:30:36 +0000

We will explore the difference between the Parse and TryParse methods in C#, and when to use each one.

int.Parse() will throw an exception int.TryParse() will return false (but not throw an exception)

What are Parse and TryParse methods?

The Parse and TryParse methods are used to convert a string representation of a number to a numeric type, such as int, long, double, decimal, etc. For example, if we have a string "123", we can use int.Parse or int.TryParse to convert it to an integer value 123.

The Parse and TryParse methods are defined on each numeric type, such as System.Int32, System.Double, System.Decimal, etc. They have different overloads that accept different parameters, such as the number format, the culture information, and the style of the number.

What is the difference between Parse and TryParse methods?
The main difference between Parse and TryParse methods is how they handle invalid input. If the string cannot be converted to a number, the** Parse** method will throw an exception, while the TryParse method will return false and not throw an exception.

For example, parse the string "abc" as an integer, the int.Parse method will throw a FormatException, while the int TryParse method will return false and assign a default value of 0 to the output parameter.

`
string input = "abc";
int result;

// Using Parse method
try
{
result = int.Parse(input); // This will throw an exception
Console.WriteLine(result);
}
catch (FormatException e)
{
Console.WriteLine(e.Message); // This will print "Input string was not in a correct format."
}

// Using TryParse method
if (int.TryParse(input, out result)) // This will return false
{
Console.WriteLine(result); // This will not be executed
}
else
{
Console.WriteLine("String could not be parsed."); // This will print "String could not be parsed."
}
`
The TryParse method does not use try/catch internally. It is implemented without exceptions so that it is faster and more efficient. In fact, it is likely that the Parse method calls the TryParse method internally and then throws an exception if it returns false.

When to use Parse and TryParse methods?
The general rule is to use Parse method if you are sure that the string will be valid and can be converted to a number. Otherwise, use TryParse method to avoid exceptions and handle invalid input gracefully.

For example, if you are reading user input from a console or a text box, you should use TryParse method to validate the input and display an error message if it is not a valid number. On the other hand, if you are parsing a string that is hard-coded or comes from a reliable source, you can use Parse method and assume that it will succeed.

However, you should always use exception handling when calling Parse method to catch any FormatException that may occur due to unexpected or invalid input. You can also use String.IsNullOrEmpty method to check for null or empty strings before attempting to parse them.

How to Keep Configuration Secrets out of a Django Project

Tino Joel Muchenje — Wed, 02 Jun 2021 21:58:55 +0000

It is best practice to hide your configuration details and not include them in version control for the sake of security and independence of project instance. Getting straight to the point here is how to do it using python decouple library.

Quick Summary

Install decouple pip install python-decouple or [https://pypi.org/project/python-decouple/].
Create file named .env or .ini under the route of your project.
Add ignore for .env if you are using git.
Retrieve the settings by importing decouple into the settings.py file and replacing variables to hide with config. 5 . Test the application

Detailed Steps

This is how our initial exposed settings.py looks like before exclusion.

import os

BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SECRET_KEY = '3izb^ryglmyscret_key_here'
DEBUG = True
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': 'HELLO_DJANGO',
        'USER': 'TINO',
        'PASSWORD': 'thepasswordhere',
        'HOST': '127.0.0.1',
        'PORT': '0000',
    }
}

1. Installing decouple

run

pip install python-decouple

or if you prefer downloading [https://pypi.org/project/python-decouple/]

2. Create .env file

Add variables to hide or exclude by copying values from settings.py making sure you do not include quotes("").

SECRET_KEY=3izb^ryglmyscret_key_here
DEBUG=True
DB_NAME=HELLO_DJANGO
DB_USER=TINO
DB_PASSWORD=thepasswordhere
DB_HOST=127.0.0.1

3. Ignoring .env from version control(git)

Go into your gitignore file and add .env as below

# Environments
.env

This will make sure our file with variables is not tracked by the source control.

4. Retrieve the settings or values on variables set in the .env file

Import config from decouple as below and reference variables as strings

from decouple import config
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
SECRET_KEY = config('SECRET_KEY')
DEBUG = config('DEBUG', cast=bool) #NB casting here for boolean
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql_psycopg2',
        'NAME': config('DB_NAME'),
        'USER': config('DB_USER'),
        'PASSWORD': config('DB_PASSWORD'),
        'HOST': config('DB_HOST'),
        'PORT': '',
    }
}

Please Note: On non string values we need to cast to the type e.g

DEBUG = ('DEBUG', cast=bool)

as DEBUG expects boolean True or False

5. Test to see if your application still run the same

Execute

py manage.py runserver

to make sure your application still run smoothly.

I have tried to go straight to the point for easier implementation. My motivation to write this down was the struggle I had to find similar information which is helpful. Feel free to suggest different implementations or suggestions.

Happy Coding!!!

DEV Community: Tino Joel Muchenje

OpenAI Drops o3 Pricing by 80% — and Launches o3-pro for Tougher Problems

OpenAI #LLM #API #DevTools #AI #GPT #MachineLearning #Coding #FunctionCalling #DeveloperExperience

Have more visibility in your APIs!

Building a Comprehensive Observability Stack for a .NET API with Core Banking Integration

Building a Comprehensive Observability Stack for a .NET API with Core Banking Integration

Introduction

The Challenge

The Solution Architecture

Implementation Steps

1. Setting Up Structured Logging

2. Adding OpenTelemetry for Distributed Tracing

3. Configuring Metrics Collection

4. Implementing Health Checks

5. Docker Compose for Observability Infrastructure

Challenges Encountered

1. Prometheus Integration Issues

2. Docker Networking Problems

3. Port Conflicts

The Final Result

Key Learnings

Conclusion

Automating Docker Deployments to Azure with GitHub Actions: A Step-by-Step Guide

Automating Docker Deployments to Azure with GitHub Actions: A Step-by-Step Guide

Why Should You Care?

What We'll Cover:

1. Prerequisites

Tools we'll be using:

Terms to know

ACI - Azure container instances

2. Setting Up Azure Resources

3. Creating an Azure Service Principal

4. GitHub Secrets and Workflows

4.1 Add Secrets to GitHub

4.2 Create GitHub Workflows

ACR Build and Push Workflow:

ACI Deployment Workflow:

5. How the Automation Works

6. Running It Yourself

7. Helpful Tips and Troubleshooting

Conclusion

Getting Started with AI for Developers: Part 1 - Demystifying the Basics

Hello, Developers!

Demystifying AI Jargon:

Different Types of AI Models:

Hands-on Example: Chatting with OpenAI using Langchain

Explanation

Further Resources:

Careful using forEach in Javascript

How to use Ruby on Rails ActiveRecord joins

Find all SsoProfiles by joining the users table

Find a SsoProfile by joining the users table and using the email attribute

# Understanding .NET 6 Configuration Files

Understanding the appsettings.json File

Handling Sensitive Data in Configuration

Network Paths in Configuration

Accessing Configuration Values

Conclusion

Learn about the difference between var, let, and const keywords in JavaScript and when to use them.

var, let, and const: What's the Difference in JavaScript?

What is a variable?

What is the difference between var, let, and const?

Conclusion

How to find non-numeric values in SQL Server

Finding non-numeric values

Conclusion

Parse vs TryParse in C#

What are Parse and TryParse methods?

How to Keep Configuration Secrets out of a Django Project

Quick Summary

Detailed Steps

1. Installing decouple

2. Create .env file

3. Ignoring .env from version control(git)

4. Retrieve the settings or values on variables set in the .env file

5. Test to see if your application still run the same

Understanding the `appsettings.json` File