Forem: Chilarai

AI can write code. But it still breaks APIs. We built a CLI to fix that!

Chilarai — Mon, 23 Mar 2026 07:09:13 +0000

AI can write your code faster than ever.

However, when you ask it to integrate Stripe, Slack, or Google, it becomes unreliable. Auth breaks. Requests fail silently. Rate limits surprise you at 2 AM. Edge cases you never thought of appear in production.

This isn't an AI problem. It's an execution problem.

The Real Trouble With API Integrations

Every developer has been here: you find the endpoint, wire it up, and ship it, then spend the next week firefighting.

OAuth tokens expiring mid-session
Retries that hammer the API and trigger rate limits
Silent failures with no structured error to catch
A library upgrade that quietly changes a parameter name
Duplicate sends because retries weren't idempotent

The standard answer? Write more glue code. Handle it yourself.

And now, with AI agents writing our code? The glue code looks more polished, but it still breaks the same ways, just faster.

The root issue is that integrations are not just code; they're execution. And execution needs to be treated as a first-class concern.

Introducing Swytchcode CLI

Swytchcode CLI is an execution layer for API integrations.

Instead of writing custom integration logic every time, the CLI gives you a controlled, deterministic way to call APIs with retries, auth, error handling, and version-awareness built in.

Think of it as separating two things that we've always conflated:

Intent: what you want to do (send a welcome email)
Execution: how it actually happens (auth, retry, response mapping, error codes)

The CLI owns execution. You (or your AI agent) just declare intent.

See It in Action

Getting Started as a Developer

Installing is straightforward:

# mac/Linux
curl -fsSL https://cli.swytchcode.com/install.sh | sh

# windows
irm https://cli.swytchcode.com/install.ps1 | iex

Now let's walk through integrating Resend (transactional email) from scratch.

Step 1: Initialize your node.js project

swytchcode init

This creates a .swytchcode/tooling.json in your project, the file that defines your execution policies, trusted tools, and integration versions. Think of it like a tsconfig.json, but for integration behavior.

Step 2: Pull the integration spec

swytchcode get resend

This fetches the Resend integration bundle that contains available methods, full parameter schemas, and endpoint definitions. No more reading through docs to figure out which fields are required or what the exact endpoint path is.

Step 3: Declare what you want to do

swytchcode add emails.email.create

This adds emails.email.create to your tooling.json with its full input schema like from, to, subject, optional html, attachments, idempotency key, and all. The CLI knows how to wire it safely.

Not sure which canonical ID to use? swytchcode list shows everything available from your fetched integrations.

Step 4: Execute

For Node.js apps, swytchcode-runtime is a thin wrapper that calls swytchcode exec for you, and no shell scripting is required. Install it alongside your app:

npm install swytchcode-runtime dotenv

Then call it directly in your code. Credentials are passed per call, never stored in your config files:

require('dotenv').config();
const { exec } = require('swytchcode-runtime');

const result = await exec('emails.email.create', {
  // `body` maps to the HTTP request body as defined by the integration spec
  body: {
    from: 'you@yourdomain.com',
    to: 'user@example.com',
    subject: 'Welcome!',
    html: '<h1>Welcome aboard!</h1>',
  },
  // your API key — passed as a request header, never stored in tooling.json
  Authorization: `Bearer ${process.env.RESEND_API_KEY}`,
});

console.log('Email sent, id:', result.id);

The runtime calls swytchcode exec under the hood, and this is the only place that actually hits the Resend API. Everything before it is set up. The CLI handles:

Auth via your API key
Retry with backoff
Structured error parsing
Deterministic, repeatable output

No hidden magic. No surprise behavior. Full control.

Using Swytchcode CLI With Cursor or Claude Code

This is where it gets interesting.

IDE agents like Cursor and Claude Code are excellent at understanding your intent and generating code, but they still produce raw API calls that can fail in production. Swytchcode changes the contract: instead of generating HTTP request code, the agent calls the CLI.

Setting it up

In your project, add a CLAUDE.md (for Claude Code) or .cursorrules (for Cursor) that instructs the agent to use the CLI for integrations:

.cursorrules / CLAUDE.md:

API Integrations


Use `swytchcode` CLI for all third-party API calls. Do not write raw HTTP requests or use SDK clients directly.

To add a new integration action:
1. Run `swytchcode get <provider>` to fetch the spec
2. Run `swytchcode add <action>` to register the action
3. In application code, use `swytchcode-runtime` to execute: `const { exec } = require('swytchcode-runtime')`

Never call external APIs directly in application code.

Now when you ask Cursor or Claude Code to "send a welcome email with Resend", instead of generating fragile SDK code, the agent runs:

swytchcode get resend
swytchcode add emails.email.create

And your application calls:

const { exec } = require('swytchcode-runtime');

const result = await exec('emails.email.create', {
  body: { from: 'you@yourdomain.com', to: 'user@example.com', subject: 'Welcome!' },
  Authorization: `Bearer ${process.env.RESEND_API_KEY}`,
});

What this looks like in practice

Say you're pair-programming with Claude Code and you type:

"Send a welcome email via Resend when a user signs up"

Without Swytchcode, the agent writes something like:

const resend = new Resend(process.env.RESEND_API_KEY);
await resend.emails.send({
  from: 'you@yourdomain.com',
  to: user.email,
  subject: 'Welcome!',
  html: '<h1>Welcome aboard!</h1>',
});

Looks fine. But: no retry handling, no structured error classification, no idempotency, and no audit trail.

With Swytchcode, the agent instead runs:

swytchcode get resend
swytchcode add emails.email.create

And application code becomes:

const { exec } = require('swytchcode-runtime');

const result = await exec('emails.email.create', {
  body: {
    from: 'you@yourdomain.com',
    to: user.email,
    subject: 'Welcome!',
    html: '<h1>Welcome aboard!</h1>',
  },
  Authorization: `Bearer ${process.env.RESEND_API_KEY}`,
});

The execution is handled by the CLI. The agent's job is to declare intent—the CLI's job is to execute it safely.

How It Works Under the Hood

Two files drive everything:

tooling.json is your execution policy and trusted tool registry:

{
  "mode": "sandbox",
  "version": "1.0.11",
  "tools": {
    "emails.email.create": {
      "type": "method",
      "integration": "resend.resend@v1.5.0",
      "summary": "Send an email",
      "inputs": [
        { "name": "body", "type": "object", "required": false },
        { "name": "Idempotency-Key", "type": "string", "required": false }
      ]
    }
  },
  "integrations": {
    "resend.resend": { "version": "v1.5.0" }
  }
}

wrekenfile.yaml is the integration spec fetched automatically by swytchcode get and stored in .swytchcode/integrations/. It defines method shapes, endpoints, and validation rules. manifest.json stores the resolved base URLs per environment (production vs. sandbox).

swytchcode exec reads all three locally and no registry calls at runtime, executes deterministically, and returns structured output you can rely on.

Why This Matters Now

We are entering an era where AI agents autonomously call APIs on your behalf. That's powerful and dangerous if the execution layer isn't sound.

Swytchcode gives you a safe boundary: AI declares intent, and the CLI executes. No malformed requests. No silent failures. No agents are going rogue because they guessed a parameter wrong.

For developers: less glue code, fewer late-night incidents.
For AI-assisted workflows: a reliable, auditable execution layer your agents can trust.

Try It

Integrations don't fail because of syntax. They fail because of execution.

If you're building anything that touches external APIs, give Swytchcode CLI a try and see how much glue code you can delete.

Install: curl -fsSL https://cli.swytchcode.com/install.sh | sh
Website: https://cli.swytchcode.com/
Docs: https://docs.swytchcode.com/cli/commands/

We're actively improving it and would love to hear what integrations you're working with. Drop a comment below or reach out directly.

Make Your API AI-Ready: Try Swytchcode's Free Playground

Chilarai — Fri, 19 Sep 2025 11:40:23 +0000

Why This Matters

The dilemma
Last month I spent two days polishing API docs—
…and still got the same questions from developers.

Good docs aren't enough anymore.
Developers want interactive playgrounds, instant code snippets, and even AI agents that can call your API on their own.

That's what Swytchcode delivers.

What Swytchcode Does

Think of it as a 24/7 solutions or support engineer for your API.

Interactive Docs & Demos – Every endpoint and workflow becomes a live playground.
MCP & AI Agents – Let AI tools discover endpoints, generate code in any language, and test workflows.
Analytics – See exactly how developers and customers are using your API and asking about it.

📣🆓 Is your API Open-source? It's free. 🎉🥳

How to Try It (3 Steps)

Open the Playground
👉 https://playground.swytchcode.ai/
Explore the Stripe Demo
Click through a ready-made workflow, run live methods, and watch how MCP exposes endpoints to AI agents.
Upload Your Own API
Drop in an OpenAPI or Postman collection and instantly get interactive docs, live calls, and analytics—no extra code.

Under the Hood

The Swytchcode plugin is built with React and can be implemented as a library in your docs/website or can be hosted as a standalone app.

The secret sauce is MCP (Model Context Protocol), which makes your endpoints discoverable by AI models and chat-based tools.

Use Cases We're Seeing

An open-source maintainer hosting docs for 200+ contributors.
A SaaS startup tracking exactly which endpoints their customers hit most.
DevRel teams turning dull API references into hands-on demos during workshops.

Ready to Give Your API a Solutions Engineer?

👉 Launch the Playground: https://playground.swytchcode.ai/
👉 Read more on https://swytchcode.com

Upload your spec, or just play with the Stripe demo. It's free for open-source projects.

Over to You

What's the biggest friction you face when onboarding developers to your API?
Drop a comment below. I'm collecting pain points to shape the next features.

The problem with current API documentation

Chilarai — Tue, 02 Sep 2025 13:49:41 +0000

Although APIs are the foundation of contemporary software, working with them frequently feels more difficult than it needs to be. The explanation, documentation, and support of APIs are the issues, not the APIs themselves. This blog will cover the common problems developers face with APIs and their documentation, the difficulties they encounter when integrating them, and how Swytchcode is helping our understanding and use of APIs.

Why Good API Documents Don’t Always Stay Good

Maintaining API documentation is more challenging than it appears. APIs change rapidly. Teams alter data structures, deprecate endpoints, and release new versions. However, updating documents is frequently neglected. Instead of writing instructions, developers are busy creating features. Managers prioritize delivery dates over the caliber of the documentation. Updates are manual and prone to errors even when they do occur. Maintaining accuracy and usefulness is difficult because of the disconnect between slow-moving documents and rapidly evolving APIs.

The following are the main problems with current API documentation:

Outdated or incomplete documents

APIs are dynamic. There are new endpoints. Older ones lose value. However, the documents frequently fall behind. What still functions is left up to the developers’ guesses. Testing endpoints that no longer behave as described is a waste of time. This discrepancy slows down projects and causes confusion.

Complex Language

Too many docs sound like they were written for machines, not people. They use jargon, vague terms, and skip key explanations. Developers need clarity, not theory. Without simple language and clear instructions, onboarding becomes slow and frustrating.

Error handling

One of the weakest aspects of the majority of API documentation is error handling. Many merely display error codes or ambiguous terms like “Bad Request.” Developers, however, require context. What caused the request to fail? How can it be fixed? Errors become hours of trial and error without solutions.

Absence of Practical Use Cases

Documents frequently provide isolated examples. They do not cover entire workflows, but they do explain syntax. For instance, you might come across a data fetch example in one location and an authentication example in another. However, you won’t notice the connection between the two steps. Chaining calls, not a single endpoint, is what real-world tasks entail. Developers must have a broad perspective.

Variability Among Endpoints

Certain endpoints provide comprehensive information, illustrations, and unambiguous answers. Others are hardly mentioned. Developers are compelled to invest more time in addressing this discrepancy. A disjointed document structure disrupts the workflow and makes integration more difficult than necessary.

No Interactivity or Testing

Many documents are static. They provide examples, but they won’t let you try them. To verify behavior, developers either write test scripts or copy snippets into Postman. That increases friction. Developers could validate their code instantly and save hours with interactive documents that included live testing.

How Issues with Documentation Cause Problems with API Integration

Inadequate API documentation impacts developers during integration. Each omitted detail or ambiguous explanation increases the effort required to get an API functioning. They spend hours guessing, testing, and debugging rather than developing features. The following section explains how common documentation issues lead to integration challenges:

Outdated or incomplete documents result in malfunctioning integrations.

Developers attempt to use endpoints that are either no longer in use or behave differently from their descriptions. Developers lose time, requests fail, and the resulting brittle code eventually breaks.

A steep learning curve

New developers find it difficult to grasp basic usage when documents are overflowing with jargon. Onboarding becomes slower. Teams begin to lose momentum.

Inadequate justifications for errors: Interminable trial and error

Without precise instructions on what constitutes an error, developers make educated guesses about solutions. Integration is delayed as minor errors become hours of debugging.

Absence of practical use cases: Inadequate workflows

Developers may functionalize individual endpoints, but they may not integrate them into a comprehensive workflow. For instance, authentication functions properly, but it breaks when combined with data retrieval.

Endpoint inconsistency: Fragile code

Developers create uneven integrations if some endpoints have adequate documentation while others don’t. They ultimately depend on conjecture, which raises the possibility of production errors.

Lack of interaction: Slow validation

Developers copy snippets to Postman or scripts in the absence of live testing tools. The additional time required for each test-and-fix cycle slows down delivery.

In summary, poor documentation causes erratic, sluggish, and annoying API integration. What ought to be a simple procedure turns into a roadblock that negatively impacts developer output and business results.

How Swytchcode Resolves Issues with API Documentation

Swytchcode improves the intelligence, interactivity, and usability of API documentation. It uses a straightforward iframe or plugin to connect straight to your website or documentation. It provides developers with live, AI-powered support for all methods, versions, and workflows in place of static text.

You can install Swytchcode as an npm package or embed it as an iframe inside your website or documentation. Once added, it works directly with your live SDK code and versioned API specs. This means your code samples and documentation always stay in sync with the latest changes. You don’t need to manually rewrite or update docs every time something changes in the API. Swytchcode ensures your documentation stays accurate, consistent, and up-to-date without extra effort from your team.

This is how it’s beneficial:

Simple-Language Definitions

API schemas are frequently complex and perplexing. They enumerate fields, types, and structures, but they hardly ever provide a human-readable explanation. Swytchcode resolves this issue by using its AI chat to explain any schema or technique in simple terms. With a straightforward, conversational explanation, a developer can ask questions like “What does this field do?” or “How do I use this method?” As a result, new developers and even non-technical managers can more easily access APIs, cutting down on onboarding time.

Code Generation in More Than 15 Languages

It takes time to write integration codes by hand, particularly when teams are using different programming languages. In over 15 languages, including Python, JavaScript, Go, Java, and Ruby, Swytchcode automatically creates method-level code. As a result, developers are no longer required to convert examples into their stack. They concentrate on developing features rather than boilerplate and replicate the usable code.

Error-proof, self-explanatory code

Error handling is one of the main issues with API code samples. The majority of documents either omit it or include ambiguous notes. Swytchcode resolves this problem by producing self-explanatory code samples. Each block addresses all error specifications, covers edge cases, and contains insightful comments. From the beginning, developers can rely on safer, more reliable integrations because they know what each line does.

Simplified Workflows

Developers rarely use a single endpoint in isolation. Steps must be chained together in real-world use cases, such as authentication, data retrieval, error handling, and more. Swytchcode automatically compiles a list of the most popular API workflows and creates the full code for each one. Developers can see how everything works together in practice rather than piecing together fragments from various sections. This increases reliability and reduces integration time.

Contextual AI Assistance

What does this error code mean? is a question that developers frequently ask themselves. Which fields are necessary? How can I make this request function? Typically, users would spend hours experimenting or searching forums. With the aid of contextual AI, Swytchcode removes that uncertainty. It foresees these queries and offers straightforward responses within the documents. As a result, developers can concentrate on building while saving time on research.

Interactive Testing

Developers are forced to write short test scripts or copy code into Postman when working with static documents. This causes friction and slows feedback. Swytchcode’s integrated interactive testing solves this problem. Within the documentation, developers can test any endpoint or workflow with actual parameters and results. They move more confidently and more quickly after receiving instant validation for their requests.

MCP integration

APIs for MCP Server Integration don’t exist in a vacuum. Teams frequently wish to link them to client apps, agents, or tools. This task is made easy by Swytchcode’s MCP server. Developers can extend the reach of their integrations without additional setup by using MCP integration to use APIs in any client that supports the protocol. Because of this, Swytchcode is an integration layer rather than just documentation.

Test live in the Swytchcode Playground:
https://playground.swytchcode.ai

Try Swytchcode for free for the first three months:

https://app.swytchcode.com

API documentation should not hinder the development of a great product. However, these days, API documentation slows down developers due to its omitted details, ambiguous language, and disrupted workflows. By transforming static documentation into an interactive, AI-powered experience, Swytchcode transforms the situation. It provides clear explanations of methods, produces dependable code in any language, responds to frequently asked developer queries, and even enables real-time endpoint testing. APIs are now as user-friendly as they should be thanks to Swytchcode, which helps teams integrate more quickly, spend less time debugging, and produce better software.

List of Programming languages in Html dropdown and Checkboxes (Hacktoberfest)

Chilarai — Sat, 01 Oct 2022 16:32:24 +0000

Very recently, while building an application, I needed a list of programming languages to be displayed for my users to select their programming interests. But, there were no known repositories which had a list of programming languages as html checkboxes/radio buttons/dropdown list. Hence, I had to code in the 50 most frequently used programming languages.

Turns out, if you Google it (I referred to Wikipedia, https://en.wikipedia.org/wiki/List_of_programming_languages), there are more than 300 known languages which people use, and the top 50 doesn't justify what people learn.

Hence, I decided to use the opportunity provided by Hacktoberfest'2022 to create the list in both dropdowns (html select options) and checkboxes with the help of user contributions.

Here is my repository: https://github.com/chilarai/list-of-programming-languages

If you feel you want to contribute to the list, please reply back to open issues so that I can assign you the particular issue. If you want to use the repo in any of your projects in the future, please feel free to do so.

List of open issues: https://github.com/chilarai/list-of-programming-languages/issues

Happy Hacking!!!

Helping students and freshers build a tech portfolio

Chilarai — Thu, 04 Aug 2022 16:04:00 +0000

Introduction

It's been two months since our version 0.1 release. We were constantly developing Techpro.club and are happy to launch version 0.2 today.

We launched the platform with the idea of helping open source projects find more contributors and adopters while as a developer you build your live developer portfolio. However, we are changing our approach to the project a little.

(Quick Recap :Introducing techpro.club: A platform to discover amazing open source projects)

What has changed?

Our Focus 👓

We are completely focusing on onboarding students and freshers who wish to build a career in Tech or are exploring the options. While early in their careers, they have a tremendous opportunity to learn and create fantastic softwares.

Techpro club is a platform to help them hone their programming skills and learn to collaborate with people early on in their careers. While they contribute to projects, ask questions, and share knowledge, we track them down in one place and help them build a better portfolio.

New Features ✨

Our new platform features a lot of new additions. Here is the summary

Fresh new layouts
Project bookmarks. You can now bookmark your favorite projects.
Project reactions help show support and love to projects
Project preview to see project details
Feeds for developers to check the latest projects
Profile management
Delete account
Github profile snapshot on your profile to track activities across Github
Project notifications for developers with matching skillsets.

Why the change?

During the past 2 months, while onboarding and interacting with students and freshers individually, we realized that many of them don't learn to code early which inhibits them from choosing the path of software development. While many have good exposure, they don't know where and how to find good projects matching their skills and they lack teamwork.

In the case of freshers, during their early days of job hunting as a software-developer, they don't have enough to showcase to potential employers.

Gist of the story 💪

The gist of the story is for early job hunting, they have a minimal Linkedin profile, Github profile, and other relevant activities which the employers really want to see in a software developer's resume.

We want to bridge the gap in their job hunting process and their lack of work experience by providing them with good projects to work with to hone their skills. Also, integrating with major platforms (such as, but not limited to, Github, Stackoverflow, Quora, etc) to bring all their activities to one place.

Why you should join?

As a developer

Techpro.club, provides the means for freshers and students to build their careers early on as software developers. We help you discover open-source projects you want to work with and while you keep working, we bring your day-to-day activities to one place. You can showcase your portfolio and thank us later.

As a project owner

Learn how to start a project and become a maintainer of a project. You will also learn to manage teams, delegate tasks, manage deadlines, releases, and many more. Good projects receive appreciation.

Road ahead

We are open-source and our services to the people will always be free. The core team will keep adding new features to make the process easier and save time for you.

In the next release, we will integrate

Project searches
Platform invites
Sharing on social media
More social platform profiles

If you want to contribute to our code, we would be glad to accept your help. Here are some important links.

Conclusion

Techpro.club is helping students and freshers build a tech portfolio early on in their careers. We have already started the onboarding process. Do join our platform.

I am willing to listen to your feedback in the comments below.

Introducing Grafieks: An open-source Analytics tool

Chilarai — Thu, 28 Jul 2022 11:19:00 +0000

Introduction

Grafieks Analytics Ltd has just released its desktop analytical tool as an open source to the public which enables students, small teams, and organizations to get better insights from their data.

Let's learn about Grafieks and how it enables you to connect with various data sources and use the available tools to create beautiful graphs and share them with your colleagues.

What is Grafieks?

Grafieks is an open-source, simple Self-Service Business Intelligence tool that allows users to quickly and easily extract meaningful insights from data. With Grafieks, line-of-business professionals can connect to data sources, build data models or write SQL queries, and build reports independently, with minimal IT support.

Why Grafieks

Businesses could use Grafieks to create, analyze, and visualize their statistics from their data. Users can easily publish meaningful graphical data to their organizations. However, for viewing published data on our cloud, you need a premium plan.

Currently, desktop and charts are open sourced under GPL v3 license. You can check the code on Github. Grafieks Desktop is available for Windows Desktop only, for the time being.

Available data connectors

List of databases, files, and online storage drives that you can connect with Grafieks to analyze. For live connection, you need your data source to be hosted on a server

CSV
JSON
Microsoft Excel
Amazon Redshift
Microsoft Access
MySql
PostgresSQL
Sqlite
Snowflake
Micorosft Sql Server
Teradata
Mongodb
Box
Dropbox
Google Drive
Online Services
Github Gists
Google Sheets

Available charts

List of charts available that you can use to create your dashboards using the data sources mentioned above

Bar Chart
- Bar Chart
- Grouped Bar Chart
- Stacked Bar Chart
- Horizontal Bar Chart
- Horizontal Grouped Bar Chart
- Horizontal Stacked Bar Chart
Line Chart
- Line Chart
- Horizontal Line Chart
- Multiple Line Chart
Area Chart
- Area Chart
- Stacked Area Chart
Pie Chart
Donut Chart
Radar Chart
Scatter Plot
Funnel
Gauge
Heat Map
Sunburst
Tree Chart
Waterfall Chart
Pivot
Table

How is Grafieks better?

Grafieks Desktop is completely open-source (GPL 3). You can use it to create your analytics for free saving up a lot on your budget. However, Grafieks do offer premium support for its services.

It seamlessly connects with data sources and lets you build many charts that are normally not available on other BI tools or require a lot of expertise on customizations and incur huge costs. Being open-source, you can easily raise bugs, fix them or speak to the developers for a feature request.

In short, the overall features have been designed keeping in mind the latest requirements for charts in an organization along with keeping cost consideration on mind.

Few Screenshots

Data connectors screen

Report designer screen

Dashboard designer screen

Closing

Grafieks is a simple business intelligence platform for data democratization while being completely open source. You are free to create your data analytics and save them for future analysis locally or live on the server.

Feel free to check out the code and contribute if you feel comfortable with the code. The code is written with QT5 (C++ 11), D3.js and Duckdb and available on Github for anyone to check and build on top of it. The core team constantly keeps adding new features.

Do let me know in the comments section below.

Introducing Techpro.club: A platform to discover amazing opensource projects

Chilarai — Thu, 16 Jun 2022 04:40:00 +0000

Introduction

What is common in Linux, VLC player, and MongoDB? Yes, they are all popular open-source softwares. Their source codes are open for anyone to use and make changes. It is the contributions from people which make these projects robust and their adopters make them popular.

However, managing an open-source project is a difficult task. It requires a lot of technical skills in terms of writing code, fixing issues, managing documentation, writing test cases, deployment, automation, CI/CD, and providing support. Then comes
the product promotion starting with writing blogs, managing social media, and optimizing for SEO. All these can be very draining and an individual cannot do all these alone.

That's where we come in. Techpro.club is an open-source platform for project owners to find the right team to build and manage their projects, however small or big they may be. At the same time, posting a project on our platform reaches out to a vast network of contributors, saving them a lot of effort and money in promotion.

Why Techpro.Club?

If you are an open-source project owner, you can take advantage of our extensive network of contributors to post your project details. We will ensure that your contribution request reaches out to the best contributors, matching your project criteria. If a matching contributor finds your project interesting, he/she can directly go to your project repository and start working. Visit https://techpro.club and register yourself

Benefits for Project owners

Find a great team to build and manage your project.
Promote your project amongst a vast network of our contributors without the hassle to promote elsewhere.
Save a lot of money.

Benefits for contributors

Opportunity to work on amazing projects.
Enhance your skills and developer portfolio by contributing to projects.
Opportunity to earn from paid projects or get hired.

Features roadmap

We are currently in the beta stage and currently accepting projects and contributors. Here is the list of features and our roadmap for the future.

[x] v 0.1
- [x] User Authentication
- [x] Contributor preferences
- [x] Projects Create, Read, Update
- [x] Registration welcome email
- [x] Master templates
[ ] v 0.2
- [ ] Profile management - avatar, delete account, etc.
- [ ] Project feeds
- [ ] Feed filters
[ ] v 0.3
- [ ] Notification for contributors
- [ ] Notification for projects
[ ] v 0.4
- [ ] Project invite members
- [ ] Project manage members
- [ ] Share on social media
[ ] v 0.5
- [ ] Project analytics
[ ] v 0.6
- [ ] Badges
[ ] v 0.7
- [ ] Integration with Gitlab
[ ] v 0.8
- [ ] Integration with Bitbucket
[ ] v 0.9
- [ ] Integration with Azure

More to follow once these are achieved.

Built With

Prerequisites

Mongodb

Install Mongodb and set the credentials in .env file described here

Github Project

Github project is needed to authenticate users. You may do so by visiting https://github.com/settings/apps. Note the Client ID and Client secret. Also, set two Callback URLs for project and contributor authentication.

Note - Create a Github App and not an OAuth App because the latter doesn't permit multiple callback URLs.

Running and Deployment

Clone the repo

git clone https://github.com/ClubTechPro/techpro.club.git

Set Environment variables

Rename the src/.env.sample to src/.env and replace it with actual credentials obtained from the steps mentioned in Prerequisites.
Install Golang dependencies
```
cd /path/to/project
go mod tidy
```
Run the project
```
go run main.go
```
Open a browser and hit http://localhost:8080

Conclusion

We want to make it easy for project owners to find a contributing team and easily promote their ideas. In the meantime, we are constantly building and similarly looking for contributors to help our community grow. If you want to contribute to us, visit our Github repository mentioned below.

Github Link: https://github.com/ClubTechPro/techpro.club
Application Link : https://techpro.club
Twitter: @ClubTechpro

Why dev.to?

Chilarai — Mon, 13 Jun 2022 16:51:15 +0000

Very very off topic. But what is the significance of .to in dev.to? Why not any other TLD or other domain?

Is it registered in Tonga?

Just asking anyone for a solid answer.Any specific idea behind this

Please don't treat me as spam

Reading GitHub secrets from GitHub actions using Golang

Chilarai — Mon, 06 Jun 2022 07:18:11 +0000

Sometimes while doing CI/CD with GitHub Actions, you need to read environment variables stored in GitHub Secrets for your tests. Here I demonstrate how you can access GitHub Secrets stored in GitHub while doing CI/CD.

Steps

Go to GitHub Repository > Settings. From the left menu, selection Secrets > Actions

Select New repository secret and add a key-value pair. For our example, we have used the key name as T1 and Value as Hello world. Then save it

Once you save it, it should be visible on the screen

Now you need to add the secret in your GitHub Actions Workflow file. You need to call the secret using

env:
    T1: ${{secrets.T1}}

Here is my Github Actions workflow

name: Go

on:
    push:
        branches: ["master"]
    pull_request:
        branches: ["master"]

env:
    T1: ${{secrets.T1}}

jobs:
    build:
        runs-on: ubuntu-latest
        steps:
            - uses: actions/checkout@v3

            - name: Set up Go
              uses: actions/setup-go@v3
              with:
                  go-version: 1.18

            - name: Build
              run: go build -v ./...

            - name: Test
              run: go test -v ./...

            - name: Environment list
              run: env

Once you do that, you should access this in your unit tests and code as

env1, err1 := os.LookupEnv("T1")
log.Println(env1, err1)

Download source code

Why do you still use Php?

Chilarai — Sun, 01 Nov 2020 16:02:24 +0000

It's not that I have anything against PHP. I have been a very avid PHP user myself and I like PHP very much. I have used it to create a lot of websites and applications.

But is it relevant now to learn for new users considering I only see a very few engagement on framework like Laravel/ WordPress? and other programming languages are gaining popularity on terms of ease, convenience on development and app processing speed?

InMemory, Columnar database - DuckDb integration with Qt for data analytics

Chilarai — Fri, 30 Oct 2020 06:22:58 +0000

For the complete repository download link, visit: https://github.com/chilarai/qt-duckdb

How DuckDB fits the role in OLAP processing

In data analytics, Columnar databases help with Online Analytical Processing (OLAP) workloads since the queries touch across a subset of columns but a large number of rows for those columns.
Also often, an embeddable database is needed that can be integrated into the program without any dependencies, just like Sqlite (a dynamic library and a header file are the only things needed to integrate with your application).
It supports SQL syntax for data query
Lastly, if the database can reside inside memory (ie, in the system's RAM), a lot of time in I/O ops is saved, and hence it's fast.

Qt5 project integration

This demo project will cover the compilation on Mac only. However, it will not be very difficult to compile on other platforms. All that is needed is to download the required binaries (linked libraries, eg, .dll, .so files) for the respective platforms.

Link to the required binaries: https://duckdb.org/docs/installation/

The following steps are already done inside the project. This is only required for fresh projects. After downloading, the following configuration needs to be done.

Copy the libduckdb.dylib & duckdb.hpp files in the Qt project root.
Adjust the .pro file to add the library. The following line needs to be added in the file for Mac

macx: LIBS += -L$$PWD/./ -lduckdb

The path can be adjusted in -L\$\$PWD/./.

For other platforms, follow the instructions on https://doc.qt.io/qtcreator/creator-project-qmake-libraries.html

Import duckdb.hpp file in the project

The `DuckCRUD` class

This class contains all the methods to connect to an InMemory instance of DuckDb and perform CRUD operations

Import duckdb.hpp file

    #include "duckdb.hpp"

Contains Q_INVOKABLE methods for CRUD operations

    Q_INVOKABLE void insertData();
    Q_INVOKABLE QStringList readTableData();
    Q_INVOKABLE void updateData();
    Q_INVOKABLE void deleteData();

A signal to notify if data is updated in the class. This signal is received on the QML code to update the view

signals:
    void dataUpdated();

Instantiate duckdb object and a connection

private:
    duckdb::DuckDB db;
    duckdb::Connection con;

In the constructor, default in-memory database, connection are defined. Also, a default table with some data is created

DuckCRUD::DuckCRUD(QObject *parent) : QObject(parent),
    db(nullptr), con(db), counter(1)
{

    // Create a table in the constructor and insert some default values

    con.Query("CREATE TABLE people(id INTEGER, name VARCHAR)");
    con.Query("INSERT INTO people VALUES (0,'Mark'), (1, 'Hannes')");
}

That's it. It was easy, wasn't it?

Spam posts in Dev

Chilarai — Sun, 04 Oct 2020 15:11:36 +0000

Suddenly, I see a lot of spam posts here with services promoting their customer care numbers like this one

https://dev.to/roygorav56/mayra-studio-customer-care-number-7318720711-7384823438-4198

Just because you want SEO ranks, you can post anything. What the heck?

You are not adding anything meaningful to this community with your customer care numbers

Cant we do something about this?