DEV Community: Atharva Shirdhankar

BlueVision : AI Workflow Intelligence for All Developers

Atharva Shirdhankar — Mon, 16 Feb 2026 07:07:03 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

I built BlueVision, an AI-powered workflow assistant for developers using GitHub Copilot CLI.

BlueVision runs in the terminal and helps developers understand commands, fix errors, refactor code, and safely execute risky operations — all in a structured and calm way.

The goal is simple:

Help developers stay focused and reduce cognitive overload while working in the terminal.

The Problem

As developers, we constantly deal with:

Long error messages
Confusing stack traces
Complex command-line tools
Multiple tasks at the same time
Pressure to fix things quickly

When something breaks, it rarely breaks in just one place.

We often see:

One error in the terminal
Another issue in logs
A failing test
A deployment warning

All at once.

This creates cognitive overload.

Instead of focusing on solving one problem properly, we jump between errors. We Google things. We open multiple tabs. We try random fixes.

Our brain is not designed to deeply process 5 problems at the same time.

And that’s where productivity drops.

The Insight

Humans perform better when they:

Focus on one task at a time
Receive structured guidance
See simplified explanations
Work step-by-step

Even though AI tools exist, most of them still dump a lot of information at once.

What developers need is not just AI answers.

They need:

Clear structure
Reduced noise
Safe guidance
One problem at a time

The Solution: BlueVision

BlueVision uses GitHub Copilot CLI in the background, but adds structure and safety on top of it.

It helps developers:

Explain commands clearly
Fix errors step-by-step
Convert natural language into safe terminal commands
Analyze code and suggest refactoring improvements
Check their current Git progress and suggest next steps
Execute risky commands safely with confirmation and risk analysis

It also includes a Calm Mode and accessibility-focused output that reduces aggressive language and presents information in smaller, clearer sections.

Instead of overwhelming the developer with information, BlueVision organizes it.

Instead of jumping between issues, BlueVision encourages solving one problem at a time.

Why This Matters

Productivity is not just about speed.

It’s about:

Clarity
Focus
Mental energy
Reduced stress

When developers feel overwhelmed, mistakes increase.

BlueVision aims to reduce that overload by turning the terminal into a guided assistant instead of a chaotic stream of errors.

It brings structure to the workflow.

It helps developers think clearly.

And that makes them more productive.

How It Works

BlueVision runs in the terminal and uses GitHub Copilot CLI in the background.

When a developer runs a command like:

explain
fix
intent
safe
devcheckin
refactor
scan-issue
pull-req

BlueVision:

Collects the relevant context (command, error, file, or git state).
Builds a structured and clear prompt.
Sends it to GitHub Copilot CLI.
Receives the response.
Reformats it into a calm, structured, and easy-to-read output.

Instead of dumping raw AI output, BlueVision organizes the response into:

Clear sections
Short bullet points
Step-by-step guidance
Risk awareness when needed

It adds a safety layer before executing risky commands and encourages solving one problem at a time.

In short:

Copilot provides intelligence.
BlueVision provides structure, safety, and clarity.

Key Features

ExplainCommand
Understand any terminal command in plain English.
IntentCLI
Convert natural language into safe shell commands.
ErrorWhisperer (fix)
Analyze error messages and get structured, step-by-step solutions.
RefactorAssist
Review code and suggest improvements for clarity and maintainability.
SafeExecution
Analyze risky commands before running them and require confirmation.
DevCheckin
Understand your current Git progress and get suggestions for next steps.
ContainerAware
Detect whether you are inside Docker, Codespaces, or local environment.
CalmMode
Reduce harsh wording and present information in a more structured way.
Accessibility-Focused Output
Break complex information into smaller sections to reduce cognitive overload.
ScanIssue
Summarize GitHub issues and suggest maintainer actions directly from the terminal.
PullRequestReview
Analyze pull requests, assess risk, and generate structured AI-assisted review feedback.

How It Helps Developers with Special Disabilities

Many developer tools assume that everyone processes information in the same way.

But that is not true.

Some developers may experience:

ADHD
Dyslexia
Autism spectrum conditions
Anxiety under high-pressure debugging
Cognitive fatigue
Visual processing challenges

BlueVision helps by:

Breaking down complex explanations into smaller steps
Avoiding overwhelming walls of text
Reducing aggressive or alarming language
Encouraging single-task focus
Structuring information clearly and predictably

Instead of flooding the user with information, it guides them calmly.

This makes the terminal less stressful and more accessible — not only for developers with disabilities, but for everyone.

Because accessibility improvements benefit all users.

Demo

Github Repo : https://github.com/StarTrooper08/blue-vision

🚀 Try It Instantly with GitHub Codespaces

BlueVision is fully compatible with GitHub Codespaces.

You can launch it directly from the repository without installing anything locally:

No manual setup
No dependency conflicts
Pre-configured development environment
GitHub Copilot CLI ready inside the container

For developers with cognitive disabilities, ADHD, or those who find complex environment setup overwhelming, removing installation and configuration steps significantly reduces mental load.

This makes BlueVision easier to try, easier to contribute to, and more accessible to everyone.

🚀 Feature Demo

Below are real examples of how BlueVision improves the developer workflow directly inside the terminal.

🔎 1. Explain Complex Commands

Understanding CLI tools like Docker, Git, or Kubernetes can be overwhelming.

Example 1 :

bv explain "SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers ON Orders.CustomerID=Customers.CustomerID;"

Output

This is **not a shell command** – it's a **SQL query** used for database operations.

## What It Does
Retrieves order information by combining data from two database tables (`Orders` and `Customers`), showing only records where a customer ID exists in both tables.

## Component Breakdown

1. **SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate**
   - Specifies which columns to retrieve from the result

2. **FROM Orders**
   - Primary table to query from

3. **INNER JOIN Customers**
   - Combines rows from `Orders` with matching rows from `Customers`
   - INNER JOIN only returns rows where a match exists in BOTH tables

4. **ON Orders.CustomerID=Customers.CustomerID**
   - Join condition: matches records where CustomerID values are equal in both tables

## Risks

- **Excludes unmatched data**: Orders without a matching customer (orphaned records) won't appear
- **Performance**: Large tables without proper indexes on CustomerID can cause slow queries
- **Missing data**: If customer records are deleted but orders remain, those orders become invisible

## Typical Use Cases

- Generating customer order reports
- Creating invoices with customer details
- Analyzing purchase history per customer
- Data validation (finding orders with valid customer references)
- Business intelligence dashboards combining relational data

**To execute this in a shell**, you'd use a database client like:
bash
mysql -u username -p database_name -e "SELECT..."
psql -d database_name -c "SELECT..."

**Example 2 :

Understanding unfamiliar code can slow down development — especially in large or legacy projects.

BlueVision allows developers to explain specific lines of code directly from the terminal.

bv explain line 28 of bluevision.sh

Output :

● Read bluevision.sh lines 20-35
  └ 16 lines read

## Explanation of Line 28

**1. What this line does:**
The line `if [ -z "$COMMAND" ]; then` checks if the `$COMMAND` variable is empty or has zero length. The `-z` test returns true if the string is empty.

**2. Why it might be used:**
This is a defensive check to provide a default behavior when the user runs the script without any arguments. If no command is specified (line 25 assigns `$1`, the first argument), the script defaults to showing help (line 29) rather than failing or doing nothing.

**3. Potential concerns:**
- **Whitespace-only values:** A command consisting only of spaces would pass this check (not zero-length) but might be invalid. Consider using `[ -z "$COMMAND" ] || [ -z "${COMMAND// }" ]` to catch whitespace.
- **Missing quotes:** The quotes around `"$COMMAND"` are essential here. Without them, an empty variable would cause a syntax error in the test.

BlueVision:

Explains what the command does
Breaks down important parts
Highlights possible risks
Shows when it should be used

Instead of searching documentation, you get a structured explanation instantly.

🧠 2. Guided Debugging (Step-by-Step Fixes)

When errors occur, developers often get stuck reading long stack traces.

bv debug "ModuleNotFoundError: No module named requests"

Output :

 Starting Guided Debug Session...

## ModuleNotFoundError: No module named requests

### 1. What This Means
Python cannot find the `requests` library in the current environment. The code is trying to `import requests`, but the package isn't installed.

### 2. Most Likely Root Cause
- The `requests` package is not installed in the active Python environment
- Or you're using a different Python interpreter than where `requests` is installed

### 3. Step 1: Install requests
bash
pip install requests


**If using Python 3 specifically:**
bash
pip3 install requests


### 4. Step 2: Check Python/pip alignment
**Verify which Python is running:**
bash
python --version
which python


**Install using the specific Python:**
bash
python -m pip install requests
# or
python3 -m pip install requests


### 5. Step 3: Virtual environment issues
**If using venv/virtualenv:**
bash
# Activate your virtual environment first
source venv/bin/activate  # Linux/Mac
# or
venv\Scripts\activate     # Windows

# Then install
pip install requests


**If no venv exists, create one:**
bash
python -m venv venv
source venv/bin/activate
pip install requests


### 6. When to Investigate Deeper
Stop and investigate if:
- ✋ `pip install requests` succeeds but error persists → Multiple Python installations conflict
- ✋ Permission errors occur → May need `--user` flag or sudo (not recommended for venv)
- ✋ Using IDE (VS Code, PyCharm) → Check interpreter selection in IDE settings
- ✋ In production/containers → Check Dockerfile or requirements.txt

BlueVision:

Explains what the error means
Identifies the likely root cause
Suggests Step 1 to fix it
Suggests what to try next if it fails

This turns debugging into a guided, structured process instead of guesswork.

🔁 3. Convert Natural Language to Safe Commands

Sometimes you know what you want to do, but not the exact command.

bv intent "remove unused docker images"

Output :

## Shell Command

bash
docker image prune -a


## Explanation

Removes all unused Docker images (images not associated with any container). The `-a` flag removes all unused images, not just dangling ones (untagged images).

## Risks

- **Data loss**: Removes images you might need later, requiring re-download/rebuild
- **Storage temporarily increases**: If you remove and rebuild, you'll use more space during rebuild
- **No recovery**: Deleted images cannot be recovered (must pull/build again)

---

**Safer alternative** (removes only dangling images):
bash
docker image prune


**Add `-f` to skip confirmation prompt**:
bash
docker image prune -a -f

BlueVision:

Generates the correct shell command
Explains what it does
Warns about potential side effects

This reduces the need to search online for CLI syntax.

🛡 4. Safe Execution with Risk Analysis

Running destructive commands in the terminal can be dangerous.

bv safe "rm -rf /"

Output :

🔎 Analyzing command safety...

❌ This command attempts to remove the root directory.
Execution blocked for safety.

BlueVision:

Analyzes the command
Detects dangerous patterns
Blocks catastrophic commands
Requires confirmation for high-risk actions

This adds an AI safety layer before execution.

📊 5. Developer Workflow Awareness (Git)

Understanding repository state is critical for productivity.

bv devcheckin

Output

● List directory .
  └ 9 files found

● Read README.md
  └ 2 lines read

● Check recent commit history and changes
  $ cd /workspaces/blue-vision && git --no-pager log --oneline -5 && echo "---" && git --no-pager
  diff HEAD~2..HEAD --stat
  └ 13 lines...

● List directory commands
  └ 8 files found

● Read bluevision.sh lines 1-50
  └ 50 lines read

● View latest commit details
  $ cd /workspaces/blue-vision && git --no-pager show d696e92 --stat
  └ 11 lines...

## Development Context Analysis

### 1. **What You're Working On**
**BlueVision** - An AI-powered CLI workflow tool for developers that integrates with GitHub Copilot. You've just added two new features:
- **guideddebug**: Interactive debugging assistance
- **githuman**: Human-friendly git operations
- Recently polished the **safe** command and **calm** (accessibility) features

### 2. **Possible Risks or Blockers**
- ⚠️ **Minimal documentation**: README has only 2 lines - users won't know how to use the 8 commands
- ⚠️ **No tests**: No test directory visible - new features lack validation
- ⚠️ **Fast-paced feature additions**: 3+ features added rapidly without integration testing
- 🔍 **Unknown stability**: The "safe" and "calm" scripts underwent polishing - may need verification

### 3. **Small, Logical Next Step**
**Document the new commands** - Add usage examples for `guideddebug` and `githuman` to the README, plus a command overview section. This helps:
- Validate the features work as designed
- Make the tool usable by others
- Force you to think through edge cases

### 4. **Cleanup/Improvement Suggestions**
- Add a `--help` flag handler for each command
- Create a `/docs` folder for detailed command documentation
- Add a CHANGELOG.md to track feature additions
- Consider adding basic smoke tests (even just shell script assertions)
- The main script could benefit from better error handling for unknown commands

BlueVision:

Reviews recent commits
Suggests next logical steps
Encourages better commit practices

This is especially helpful for open-source contributors.

♻ 6. Code Refactoring Assistance

Improving code readability and structure is easier with guidance.

bv refactor app.py

Output

♻ Analyzing file for refactoring improvements...

## Code Review: Refactoring Suggestions

### 1. **Code Structure**

**Issues:**
- All business logic, UI, and data operations mixed in `main()`
- No separation between data layer, business layer, and presentation layer

**Suggestions:**
- Extract menu display logic into a separate function
- Create a `UserService` class to handle API interactions
- Create a `DataRepository` class for file operations
- Keep `main()` as a simple orchestrator

---

### 2. **Naming Improvements**

**Issues:**
- `getData()` / `saveData()` → Too generic
- `d`, `f`, `r`, `id` → Single-letter variables
- Function names not following PEP 8 (should be `snake_case`)

**Suggestions:**

getData()     → get_saved_user_data() or read_user_cache()
saveData()    → save_user_data() or cache_user_data()
fetchUser()   → fetch_user_by_id()
d             → data or user_data
f             → file or file_handle
r             → response
id            → user_id


---

### 3. **Error Handling**

**Critical Issues:**
- No exception handling for file I/O (permissions, disk full)
- No handling for HTTP errors (404, 500, network timeout)
- No validation of user input (non-numeric IDs)
- Unsafe dictionary access: `user["name"]` can raise KeyError

**Suggestions:**
python
# File operations need try-except
try:
    with open(DATA_FILE, "r") as f:
        return f.read()
except FileNotFoundError:
    return ""
except IOError as e:
    # Handle error appropriately

# HTTP requests need error handling
response.raise_for_status()  # Check for HTTP errors
if response.status_code == 200:
    user_data = response.json()
    # Validate JSON structure before accessing

# Input validation
if not user_id.isdigit():
    print("Error: User ID must be numeric")


---

### 4. **Separation of Concerns**

**Issues:**
- `main()` handles UI, business logic, and data persistence
- File operations directly in business logic
- No abstraction layers

**Suggestions:**
- **Data Layer**: Class/module for file operations
- **Service Layer**: Class for API calls and business logic
- **UI Layer**: Functions for user interaction and display
- **Main**: Orchestrate the flow only

BlueVision:

Reviews the file
Suggests structural improvements
Recommends clearer naming and patterns

This supports maintainability and clean code practices.

🧘 7. Accessibility Mode

For developers who prefer simplified output:

bv --accessible explain "kubectl delete pod"

Output

🔵 Accessible Mode Enabled
----------------------------------------

# kubectl delete pod

## What It Does
- Removes a running pod from your Kubernetes cluster
- Terminates all containers inside the pod
- Frees up the resources the pod was using
- **Note**: This command is incomplete - it needs a pod name (e.g., `kubectl delete pod my-pod`)


----------------------------------------
Output simplified for clarity.
Use without --accessible for full detail.

BlueVision:

Uses simpler language
Breaks output into small sections
Reduces information density
Encourages step-by-step understanding

This helps reduce cognitive overload and makes terminal workflows more inclusive.

📊 8. GitHuman – Maintainer Intelligence

Open-source maintainers often struggle with:

Poor commit messages
Inconsistent contribution patterns
Hard-to-review changes

With BlueVision:

bv githuman

Output

 Analyzing recent commit history...

● Get last 10 commits
  $ git --no-pager log --oneline -10
  └ 5 lines...

● Get detailed commit messages
  $ git --no-pager log --format="%h %s%n%b" -10
  └ 8 lines...

## Commit Message Quality Analysis

### **Observations:**
1. **Inconsistent capitalization** - Mix of lowercase ("added", "polished", "initial") and title case ("Initial commit")
2. **Vague descriptions** - "polished" and "added" don't explain *what changed* or *why*
3. **Typos/spacing** - Extra space in "added :" suggests formatting issues
4. **No conventional format** - Missing type prefixes (feat:, fix:, docs:)
5. **No commit bodies** - Zero context or explanation for any change

### **Does NOT Follow Good Practices:**
- ❌ Imperative mood (should be "Add" not "added", "Polish" not "polished")
- ❌ Clear, descriptive summaries
- ❌ Conventional commits format
- ❌ Explanatory bodies for non-trivial changes

### **Suggestions:**
1. **Use conventional commits**: `feat: add guided debug and githuman features`
2. **Write in imperative mood**: "Add feature" not "added feature"
3. **Be specific**: Instead of "polished", describe what was improved
4. **Add bodies for complex changes**: Explain the *why* and *what*
5. **Keep first line under 50 chars**, body wrapped at 72

### **Recommendations:**
- Adopt a commit message template or linter (e.g., commitlint)
- Consider semantic versioning triggers (feat/fix/BREAKING)
- Each commit should answer: *What* changed and *why* it matters

BlueVision:

Analyzes recent commit history
Reviews commit message quality
Suggests improvements
Encourages better maintainability practices

It acts like an AI assistant for repository hygiene.

This helps:

Open-source maintainers
Contributors writing better commits
Teams improving collaboration standards

📂9. Scan and Summarize GitHub Issues

Open-source maintainers often spend time reading long issue threads just to understand the actual problem.

BlueVision simplifies that process.

bv scan-issue chainguard-dev/apko 2059

Output :

📂 Fetching issue #2059 from chainguard-dev/apko...

## Issue Analysis

### 1. Summary
Building a container with apko using Alpine edge repositories results in an unusable container. Running `apk info` inside fails with "v2 database format error" indicating the apk database was written incorrectly.

### 2. Main Technical Problem
- **Root cause**: The `i:` (install_if) field in the generated APK database index appears to be serialized with brackets `[]` (array format)
- **Expected**: According to apk documentation, `i:` should be a space-concatenated single line, not an array
- **Impact**: Incompatible database format prevents apk-tools from reading the package database
- **Likely location**: `pkg/apk/apk/apkindex.go` (per commenter suggestion)

### 3. Clarification Needed
- **Minimal**: Issue is well-described with clear reproduction steps
- **Nice to have**: 
  - apko version used
  - Actual database content showing malformed `i:` field
  - apk-tools version in resulting container

### 4. Suggested Maintainer Action
1. **Investigate** `pkg/apk/apk/apkindex.go` for install_if serialization logic
2. **Verify** against apk APKINDEX format specification
3. **Fix** serialization to output space-delimited string instead of array notation
4. **Add test** to prevent regression with install_if field formatting

### 5. Duplicate Likelihood
**Low** - This is a specific serialization bug. Would search for "install_if", "database format", or "v2 database" in existing issues to confirm.

BlueVision:

Fetches issue details using GitHub CLI
Analyzes the title, description, and metadata
Summarizes the core problem
Identifies the likely technical concern
Suggests next steps for maintainers
Flags if clarification or duplication might be needed

Instead of manually parsing long discussions, maintainers get a structured summary in seconds.

This reduces cognitive overload and speeds up triaging.

Why This Matters

Maintainers often deal with:

Long issue descriptions
Incomplete bug reports
Repetitive questions
Duplicate issues

BlueVision acts as an AI triage assistant inside the terminal.

It helps maintainers:

Quickly understand context
Decide whether to request clarification
Prioritize issues more effectively

By combining GitHub CLI and Copilot CLI, BlueVision transforms issue management into a guided and structured workflow.

10. 🔎 AI-Assisted Pull Request Review

Reviewing pull requests can be time-consuming, especially when changes are large or involve multiple files.

BlueVision helps maintainers quickly understand what a PR does and what to look for.

bv pull-req github/copilot-cli 1120

Output :

🔎 Fetching PR #1120 from github/copilot-cli...

## Code Review: GitHub Actions TKE Deployment Workflow

### 1. High-Level Summary
Adds a GitHub Actions workflow that builds a Docker image, pushes it to Tencent Cloud Registry, and deploys to TKE on main branch pushes. The workflow uses Kustomize for Kubernetes deployments and requires four secrets for authentication.

### 2. Risk Level
**HIGH** - Contains security vulnerabilities and critical functional bugs that will cause deployment failures.

### 3. Potential Bugs & Edge Cases

**Critical Issues:**
- **Line 49**: Docker login syntax is incorrect. `${TKE_IMAGE_URL}` includes the full image path, not just the registry hostname. Should be `ccr.ccs.tencentyun.com`
- **Line 76**: `kustomize edit set image` is incomplete - missing the image name/selector before the URL
- **Line 44**: No validation that `Dockerfile` exists in repository root
- **Line 70**: Context name assumes a specific naming pattern that may not exist

**Edge Cases:**
- No handling for when deployment already exists vs. new deployment
- Missing validation that required Kubernetes manifests exist (deployment.yml, kustomization.yml)
- No timeout specified - deployment could hang indefinitely
- Kustomize commands assume current directory structure without verification

### 4. Code Quality Concerns

**Security:**
- Secrets may leak in workflow logs despite single quotes
- No image vulnerability scanning before deployment
- Using account credentials for registry (consider service account)
- Downloading binary from GitHub without checksum verification (line 57)

**Outdated Dependencies:**
- Kustomize v3.1.0 (2019) is extremely outdated - current is v5.x
- Missing security patches and features

**Configuration:**
- Demo/placeholder values in env vars should have clear documentation
- Hard-coded registry hostname in multiple places

### 5. Maintainability Concerns

- **No rollback mechanism** if deployment fails
- **No cleanup** of built images or resources
- **No tagging strategy** - only uses Git SHA (consider semver tags)
- **Missing documentation** on required Kubernetes manifest structure
- **No environment-specific configuration** - production hardcoded
- **Missing health checks** between deployment steps
- Manual curl download instead of using GitHub Actions marketplace actions

### 6. Suggested Review Comments

yaml
# Line 49 - BLOCKER
- docker login -u ${{ secrets.TENCENT_CLOUD_ACCOUNT_ID }} -p '${{ secrets.TKE_REGISTRY_PASSWORD }}' ${TKE_IMAGE_URL}
+ docker login -u ${{ secrets.TENCENT_CLOUD_ACCOUNT_ID }} -p '${{ secrets.TKE_REGISTRY_PASSWORD }}' ccr.ccs.tencentyun.com

**Issue**: Registry URL should be just the hostname, not the full image path.

yaml
# Line 57 - HIGH PRIORITY
- curl -o kustomize --location https://github.com/kubernetes-sigs/kustomize/releases/download/v3.1.0/kustomize_3.1.0_linux_amd64
+ curl -s "https://raw.githubusercontent.com/kubernetes-sigs/kustomize/master/hack/install_kustomize.sh" | bash

**Issue**: Kustomize v3.1.0 is 7 years old. Use latest stable version.

yaml
# Line 76 - BLOCKER
- ./kustomize edit set image ${TKE_IMAGE_URL}:${GITHUB_SHA}
+ ./kustomize edit set image ${DEPLOYMENT_NAME}=${TKE_IMAGE_URL}:${GITHUB_SHA}

**Issue**: Missing image name selector - command will fail.

**Additional Recommendations:**
1. Add image scanning step (Trivy/Snyk) before push
2. Add deployment timeout: `kubectl rollout status --timeout=5m`
3. Implement rollback on failure
4. Add validation step to check required files exist
5. Use registry cache/buildx for faster builds
6. Add step to create/tag release after successful deployment
7. Consider using composite actions for reusability
8. Add notifications on deployment success/failure

**Documentation Needed:**
- Required Kubernetes manifest files and structure
- How to configure environment-specific values
- Rollback procedure
- Prerequisites checklist

BlueVision:

Fetches PR metadata using GitHub CLI
Retrieves the code diff
Analyzes the changes using Copilot CLI
Generates a structured review summary

Instead of manually scanning hundreds of lines of diff, maintainers receive:

A high-level summary of changes
Risk assessment (Low / Medium / High)
Potential bugs or edge cases
Code quality concerns
Maintainability suggestions
Suggested review comments

Why This Matters

Maintainers often deal with:

Large pull requests
Time pressure
Subtle edge cases
Community contributions from different skill levels

BlueVision acts as an AI co-reviewer inside the terminal.

It doesn’t replace human review — it enhances it.

By summarizing changes and highlighting risks, it helps maintainers:

Review faster
Catch potential issues earlier
Make better decisions with less cognitive strain

This turns the CLI into a structured review assistant rather than just a diff viewer.

🎯 What This Demonstrates

Through these features, BlueVision:

Reduces context switching
Simplifies complex CLI workflows
Prevents risky mistakes
Guides debugging step-by-step
Makes terminal interaction more accessible

It transforms the terminal from a reactive tool into a guided AI workflow assistant.

My Experience with GitHub Copilot CLI

I genuinely enjoyed working with GitHub Copilot CLI.

I’ve always preferred working in the terminal and Linux environments. For me, the CLI feels fast, direct, and powerful. So building something on top of Copilot CLI felt natural and exciting.

What impressed me most was how flexible it is.

Copilot CLI is not just a command explainer — it’s a reasoning engine inside the terminal.

While building BlueVision, I used Copilot CLI to:

Generate structured debugging logic
Refine prompt formats
Improve clarity of AI responses
Experiment with safety-aware command analysis
Shape step-by-step structured guidance

It allowed me to think beyond simple command explanations and build a workflow layer on top of it.

Copilot provided intelligence.

BlueVision shaped that intelligence into something structured, safe, and accessibility-focused.

How GitHub Copilot CLI Helped Me Build BlueVision

During development, Copilot CLI helped me:

Quickly prototype command behaviors
Refine error analysis prompts
Improve safety-check structures
Think about better user interaction flows

Because everything runs in the terminal, the feedback loop was fast.

I could:

Modify prompt structure
Test instantly
Refine output behavior
Improve formatting

This rapid iteration cycle made development smooth and productive.

It felt like building with an AI collaborator — not just using an autocomplete tool.

Why This Matters

GitHub Copilot CLI shows how AI can move beyond writing code.

It can:

Guide workflows
Improve decision-making
Reduce mental load
Add safety layers
Support accessibility

BlueVision demonstrates how Copilot CLI can be extended into a structured developer workflow assistant.

Not just generating answers — but shaping how developers interact with problems.

BlueVision stands out because it:

Extends Copilot CLI instead of just using it
Focuses on reducing cognitive overload
Introduces an accessibility-first modifier
Adds a safety-aware execution layer
Supports both developers and maintainers
Integrates smoothly with GitHub Codespaces

It combines:

AI reasoning
Structured UX design
Terminal-native workflows
Inclusive design thinking

Closing Statement

BlueVision transforms GitHub Copilot CLI into a structured, safety-aware, and accessibility-first workflow assistant for developers.

It reduces cognitive overload, guides debugging step-by-step, and prevents risky terminal mistakes — all inside the CLI.

By combining AI reasoning with thoughtful design, BlueVision makes the terminal calmer, smarter, and more inclusive.
It’s not just about faster development — it’s about clearer thinking.

Meteora

Atharva Shirdhankar — Thu, 20 Nov 2025 11:50:41 +0000

Draft

Blog writing in progress...

Application Info

CartoonSpace with Complete Python Flask-OpenCV Dev Environment

Atharva Shirdhankar — Tue, 23 May 2023 22:36:58 +0000

What I built

The Github Codespace and Github Actions has became one of my favourite tools of all time. So tried to build something using it.
I've build a sketch app which lets user create a sketch by taking image as input and create a cartoon version of it.

Category Submission: DIY Deployments, Maintainer Must-Haves, Wacky Wildcards

App Link

Dockerhub :
Docker cmd to try out CartoonSpace App:

docker pull atharvas08/cvflaskcodespace

Screenshots

Sreenshots from Codespaces:

Dockerhub :
Docker cmd to try out CartoonSpace App:

docker pull atharvas08/cvflaskcodespace

Successfully Build and Push FlaskOpenCV app docker image to dockerhub using github actions workflow.

Slim Actions Workflow Report for the Following CartoonSpace app docker image:
https://github.com/StarTrooper08/CVFlaskCodeSpace/actions/runs/5062637681/jobs/9088369333

Description

I also faced a problem while developing the application locally like dependencies where not getting installed for application and also I have to continously build docker image and push it to dockerhub, so that I can share my application with others. And also optimize docker image locally using slimtoolkit.

So I also thought why not create a codespace template which can let flask developers to easily create OpenCV flask application on codespace and also automate build,optimize and push docker image to dockerhub.

So its like 2 in 1 project one solves the problem and other is just fun project.

Fan Fact: The CartoonSpace is completely created on Codespaces.
Firstly I created the flask-opencv template and then upon it created the CartoonSpace App.

Link to Source Code

https://github.com/StarTrooper08/CVFlaskCodeSpace

The cartoonspace project is on the cartoonspace github branch.
The main branch consist of the flask-opencv dev env template. One can easily get started with developing flask-opencv app right away without any much installation.

Permissive License

MIT License

Background (What made you decide to build this particular app? What inspired you?)

Since, from the Generative AI era has started I wanted to create something similar to midjoruney. After some exploration I came across OpenCV and Hugging Face and many other tools.
So I tried OpenCV and when I was doing the develpment process locally of this application I came across different problems I mentioned before in description. So I thought why not to create a codespace dev environment which can solves this issue, if someone wants to create flask-opencv app and build docker image of it.

How I built it (How did you utilize GitHub Actions or GitHub Codespaces? Did you learn something new along the way? Pick up a new skill?)

Github Actions

I created a workflow which build and push docker image to dockerhub.
And also created a workflow using slimtoolkit which creates docker report.

Github Codespace

One can get started with flask-opencv app dev right away with the codespace template which is present on main branch.

Expense Stream | Streamlit and MongoDb Atlas App

Atharva Shirdhankar — Thu, 08 Dec 2022 23:15:28 +0000

Background

Since there is rise in inflation and continous happening of recession, which is a stressful thing. But to tackle this stressful scenerio there is one solution keeping track of our budget and manage money in great way. So I thought of creating this Expense tracking web app which will be helpful in tracking expense monthwise.

What I built

I've built this web app using streamlit and mongodb atlas cluster to store data. It takes input like Total income available to spend and yeah even takes our spending and needful expenses as input and then it is stored into Mongodb database monthwise.
And when we want to look for our data we can visualize in nice sankey chart form. Sankey chart shows the flow of earning and spending in great way.

Category Submission:

Think Outside the JS Box

App Link

https://expensestream.azurewebsites.net/

Screenshots

Save Chart as an png image feature :

Description

Helping you to track your earnings and spending.

Link to Source Code

StarTrooper08 / ExpenseStream

Helping you to track your earnings and spending.

ExpenseStream

View on GitHub

Permissive License

MIT License

How I built it

(How did you utilize MongoDB Atlas? Did you learn something new along the way? Pick up a new skill?)

Development Process :

Setup and Initiating Virtual Environment

Create empty github repository with readme.md and license file.
Clone the repository locally git clone https://github.com/StarTrooper08/ExpenseStream.git
cd to the project file and initiate virtual env
gitignore venv folder so that we dont push venv directory to github repo
Install python libraries Python libraries : streamlit, plotly, pymongo and streamlit_option_menu

pip install streamlit plotly pymongo streamlit_option_menu

Coding Part :

For this application we will create two python files one will be the app.py where our frontend code and which will interact with database file for adding and fetching data from Mongodb database. And other file name database.py will be dedicatedly used to create database functions which will help us create document inside our collection and get document from it when called in app.py file.

Now lets create app.py inside our Expense Stream directory and write some code

App.py file

#imports for our app
import streamlit as st
import plotly.graph_objects as go
from streamlit_option_menu import option_menu

import calendar
from datetime import datetime

import database as db 

#variables
incomes = ["Salary","Blog","Other Income"]
expenses = ["Rent","Utilities","Groceries","Car","Saving"]
currency = "USD"
page_title = "Expense Stream"
page_icon = ":money_with_wings:"
layout = "centered"

#setting title for our app
st.set_page_config(page_title=page_title, page_icon=page_icon, layout=layout)
st.title(page_title + " " + page_icon)


years = [datetime.today().year, datetime.today().year + 1]
months = list(calendar.month_name[1:])

def get_all_periods():
    items = db.fetch_all_periods()
    periods = [item["key"] for item in items]
    return periods

hide_st_style = """
<style>
#MainMenu {visiblility: hidden;}
footer {visiblility: hidden;}
header {visiblility: hidden;}
</style>
"""

st.markdown(hide_st_style,unsafe_allow_html=True)

selected = option_menu(
    menu_title= None,
    options=["Data Entry","Data Visualization"],
    icons=["pencil-fill","bar-chart-fill"],
    orientation= "horizontal",
)


if selected == "Data Entry":
        st.header(f"Data Entry in {currency}")
        with st.form("Entry_form", clear_on_submit=True):
            col1, col2 = st.columns(2)
            col1.selectbox("Select Month:", months, key= "month")
            col2.selectbox("Select Year:", years, key="year")


            with st.expander("Income"):
                for income in incomes:
                    st.number_input(f"{income}:",min_value=0, format="%i", step=10,key=income)
            with st.expander("Expenses"):
                for expense in expenses:
                    st.number_input(f"{expense}:", min_value=0,format="%i",step=10,key=expense)
            with st.expander("Comment"):
                comment = st.text_area("", placeholder="Enter a comment hee ...")



            submitted = st.form_submit_button("Save Data")
            if submitted:
                period = str(st.session_state["year"]) + " " + str(st.session_state["month"])
                incomes = {income: st.session_state[income] for income in incomes}
                expenses = {expense: st.session_state[expense] for expense in expenses}
                db.insert_period(period,incomes,expenses,comment)
                st.success("Data Saved!")





if selected == "Data Visualization":
        st.header("Data Visualization")
        with st.form("Saved periods"):
            period = st.selectbox("Select Period:", get_all_periods())
            submitted = st.form_submit_button("Plot Period")
            if submitted:
                period_data = db.get_period(period)
                for doc in period_data:
                    comment = doc["comment"]
                    expenses = doc["expenses"]
                    incomes = doc["incomes"]


                total_income = sum(incomes.values())
                total_expense = sum(expenses.values())
                remaining_budget = total_income - total_expense
                col1, col2, col3 = st.columns(3)
                col1.metric("Total Income",f"{total_income} {currency}")
                col2.metric("Total Expense",f"{total_expense} {currency}")
                col3.metric("Remaining Budget",f"{remaining_budget} {currency}")
                st.text(f"Comment:{comment}")


                label = list(incomes.keys()) + ["Total income"] + list(expenses.keys())
                source = list(range(len(incomes))) + [len(incomes)] * len(expenses)
                target = [len(incomes)] * len(incomes) + [label.index(expense) for expense in expenses.keys()]
                value = list(incomes.values()) + list(expenses.values())


                link = dict(source=source, target=target,value=value)
                node = dict(label=label,pad=20,thickness=25,color="#00684A")
                data = go.Sankey(link=link,node=node)

                fig = go.Figure(data)
                fig.update_layout(margin=dict(l=0,r=0,t=5,b=5))
                st.plotly_chart(fig, use_container_width=True)

We can give theme to our app using streamlit config toml file, which will make our app design look great and consistent.
First we will create .streamlit/config.toml directory inside our parent project directory.

.streamlit/config.toml

[theme]

primaryColor = "#00684A"

backgroundColor = "#002b36"

secondaryBackgroundColor = "#586e75"

textColor = "#fafafa"

font ="sans serif"

Before we create database.py file and write code into it first lets setup Mongodb cluster for us to use.

First click on project dropdown here you will find your existing project but we want to create new project we will click on new project and after that we will be asked to add members to our cluster but we will keep it as it is and move forward.
After that we will click on Create database.
Then Select deployment option we will select free tier since this is just a demo app.
Select cloud provider and region for your cluster. Here I'm selecting GCP and my prefered region which is to close to me. After selecting cloud provider and region,click on create cluster.
Now we will asked to create user and password and add our local ip address. Its super simple to do just click on add ip address button and it will done automatically.
Within few minutes our cluster will be created.
Now we have to connect our application to it. So we will click on connect button on the right side of our database section.
After that we will get 4 options we will select connect your application one.
After clicking on it we will get popup asking for our application language and version. We will select python and version we have installed on our local machine.
After that we will get our cluster access link. Just one changes we have to make while using the link. Instead of embeded inside the link we have to pass actual password which we given earlier(step 5). Password can be passed using env variable for security purpose. I'm passing it directly for now.

And that's it we are done with setting up our first MongoDB Atlas Cluster.

Now lets use it in our application. To do use it I'm creating database file where I'll connect to database and do data operations.

database.py file

import pymongo
from pymongo import  MongoClient

cluster = MongoClient("mongodb+srv://atharvas08:<password>@cluster0.jtpc66a.mongodb.net/?retryWrites=true&w=majority")

db = cluster["monthly_reports"]
collection = db["expense_data"]


#insert period as a document inside our mongodb
def insert_period(period,incomes,expenses,comment):
    return collection.insert_one({"key":period,"incomes":incomes,"expenses":expenses,"comment":comment})

def fetch_all_periods():
    res = collection.find()
    return res

def get_period(period):

    if not isinstance(period, dict):
        period = {"key": period}

    return collection.find(period)

Now lets create requirements.txt file for our app so that we can easily deploy it on internet.

dnspython==2.2.1
plotly==5.11.0
pymongo==4.3.3
python-dateutil==2.8.2
requests==2.28.1
streamlit==1.15.2
streamlit-option-menu==0.3.2

Dockerfile

FROM python:3.9-slim
COPY . /app
WORKDIR /app
RUN pip3 install -r requirements.txt
EXPOSE 8501
ENTRYPOINT ["streamlit", "run", "app.py", "--server.port=8501", "--server.address=0.0.0.0"]

Additional Resources/Info

Sankey Chart/Diagram:
https://developers.google.com/chart/interactive/docs/gallery/sankey

Mongodb atlas and pymongo doc:
https://www.mongodb.com/languages/python

Streamlit:
https://docs.streamlit.io/

How I use Peerlist to build my Portfolio?

Atharva Shirdhankar — Sun, 25 Sep 2022 18:26:58 +0000

Have you ever participated in Hackathon? Ever Contributed to Open Source? If not!
Then this blog is for you. I'll be sharing my Hackathon experiences and Learnings from Open Source contributions. Moreover, how I used Peerlist to build my portfolio for Open Source Contributions and Hackathon Projects.

Hackathon Experience

When I first came across term Hackathon. I was overwhelmed and used to think questions like!
How these folks create amazing projects that too in short time?,
How these folks do project pitching to judges so well?, etc.

After that I teamed-up with one of my friend and both participated in one 12 Hours in-person Hackathon in 2019. We have to build any application(Web/Mobile) or any create something in innovative way using any technology on topics like Education, Environment etc.
We created Mobile application half on Environment topic. Didn't make it for any prize for that Hackathon but it was alright, it was completely new experience for me and my friend and we learn new stuff.
That's how I started with Hackathon in-short.

What type of Hackathon should a Beginner Participate?

As a beginner I'll suggest to participate in 1 month or more timeline Hackathon as a Beginner.This will give you enough time to create project and explore new technolgy and even if you don't find any team member for Hackathon you can work alone cause of 1 month or more timeline.
Many hackathon are based on Technolgy instead of some theme.
Like I participated in Devto Hackathon where we have to create project using Github Actions and Azure services.

Some advantages of Hackathon:

You learn new Technology and sometimes even complete Tech Stack.
Network with amazing Hackers around the globe (online hackathon)
Learn to work in limited time.
Fun and Collaboration with team members(which is important in Software Development world).
Bonus - Swags , Prizes and free food(free food only available in in-person hackathons)

With advantages there also comes some disadvantages or flaws :

Since in some hackathon we have to work straight for 12 or 24 Hrs . It may put us in stress and mental health. Tip - So as a beginner start with month long Hackathons.

Do give this Mental Health Blog a read[Peerlist] :
https://blog.peerlist.io/how-to-protect-your-mental-health-when-working-remotely/

Links to Hackathon Platforms:

These platforms organizes both online and in-person Hackathons. You will find multiple Hackathon running at same time. And you can participate in hackathon whichever you find great Hackathon theme you would love to work.

Hackathon and Writeothon/Blogathon :
https://dev.to/
https://hashnode.com/

These platform organizes online Hackathons and Writeothon both on monthly basis.

Open Source Contribution :

I started Open Source contribution from 2020 Hacktoberfest.
Since Open Source contribution was new and use to get overwhelmed with huge codebase.
So I came across Github projects Documentation which was open source.
I just asked maintainer how can as a beginner contribute to documentation and they guided me.
And slowly steadily started to contribute other projects also which contains code.

Tips to get Started Open Source Contributions:

First learn git and github's fundamentals like how to clone repo, how to push to github, how to create branch, how to manage merge conflict etc. Then you are good to go.
Initial start contributing to Documentation of Open source projects. Cause documentation makes you comfortable with git and githubs workflow. And even documentation contains how to setup locally project and it has info regarding codebase. You will slowly and steadily learn.
Open Source is all about community. So join Open Source community(Suggestion: EddieHub). Eddiehub is amazing and inclusive community for Open Source and tech enthusiast.

Now on lets get on main topic.

How I use Peerlist to build my Portfolio?

There are multiple features and Integrations available on peerlist platform integrations like Hashnode, github, dribble, devto , Medium , RSS , gumroad and many more which are useful for developer to designers to build there portfolio.

But my personal favourite are Github and custom project.

Github integration : This is amazing integrations cause one can add their open source contributions projects. Even we can verify our Github account on peerlist. And classic github contribution graph is also displayed.

*Custom Projects:

This integrations is helpful to showcase side projects or Hackathons projects.

Why I use Peerlist Github pin repo feature to showcase my side projects?

I use github integration only for Open Source projects to which I have contributed and still working on. In one of the Open Source twitter space I heard from Open Source dev that Open Source contributions puts great impact which recuirters search for and this also depicts your favourite tech stack and codebase you are familiar with.

Reasons to Join Peerlist :

Amazing UI of the platform which makes it easy to use.
Multiple integrations which makes helpful for Designers and Devs.
Jobs section
Scroll where amazing folks network.

Peerlist Profile : https://peerlist.io/_Atharva_08

3 Best Tools that you can use for Writing Awesome Articles

Atharva Shirdhankar — Sat, 19 Mar 2022 12:48:40 +0000

3 Best Tools that you can use for writing an article that will surely Sky Rocket your article reader's experience.

Whenever I write technical articles on programming or development. I like to add some code snips and explanatory illustrations.

So here are some tools that I have used for a long time and a few just started to use.

1. Excalidraw

(This example image is created using poet.so)

The fascinating tool currently I have started using for my articles is Excalidraw.
(those articles are draft currently but soon will be released)

It helps us create illustrative diagrams easily.
It is Free & Open Source and basic features are more than enough. And need some more advanced features, you can just get a premium subscription called Excalidraw+.
It has awesome collections of the library which has Icons, UML blocks and elements, and many more to create awesome explanatory diagrams.

Link : https://excalidraw.com/

excalidraw / excalidraw

Virtual whiteboard for sketching hand-drawn like diagrams

2. Snappify

Who doesn't like to add some code snippets in their article?
So here is one amazing and easy-to-use tool that creates code snippets for us seamlessly.

It is free with basic features and that's enough I guess for us to use in our article.

It has customization for background gradient colour.
Size customization option for the snippet image.
Theme customization option.

Link : https://snappify.io/

3. Poet.so

Few a times we need to add a Twitter thread in our article.
For example, many folks do #100daysoflearning in public and they create a thread on Twitter, so if they want to add that Twitter thread snap in the article and can be done using poetso.

We have the option to include likes, retweets, and comments responses in the tweet snap image.
It has different background gradient color.
Size customization option of the tweet snap.

Link : https://poet.so/

Birthdate Speciality | Azure SpringBoot

Atharva Shirdhankar — Tue, 08 Mar 2022 19:50:44 +0000

Hey,have you ever counted how many days are left for your birthday?Whats your birthstone? What's your Zodiac and Shēngxiào? No!
Don't worry this web app will find it for you.

Submission Category: Java Jackpot

Overview of My Submission

Hello everyone, here is my Fun type Java Spring boot web app which will help you count days left for your next Birthday.
And Moreover,it will tell you your Birthstone,zodiac,etc.

Lets start building the project and deploy it on Azure Web Service for Java

Setup and requirements for this project :

Java Framework : Spring Boot
Project Management Tool : Maven
IDE : IntelliJ
IntelliJ plugin : Azure Toolkit for Intellij
Deployment : Azure
Browser : Chrome

and yes some coffee...

Step 1: Download SpringBoot Template from Spring Initializr

Spring Initialzr helps us to create Spring boot Web app in easy way. It also has amazing option to add dependencies to our springboot app.

Link : https://start.spring.io/
(official website from SpringBoot)

Here is the Screenshot of this project bootstrapping with the help of Spring Initializr

Give your project name and Description(you can also change the group but I have left it default)
Dependencies : Spring Web, Spring Boot Devtools, Thymeleaf(Template engine).
Select the options
- Project : Maven
- Language : Java
- SpringBoot version : Leave it Default selected
- Packaging : jar
- Java : 11

Then click on 'GENERATE'. Zip file will be downloaded.

Yay!!!Our initial setup is ready🎉.

Step 2: Java Spring Boot Web App Code

StarTrooper08 / BirthdateSpeciality

Fun kind of SpringBoot project which shows details regarding Birthdate(days left for next birthday, zodiac,etc)

BirthdateSpeciality

Explantory Blog : https://dev.to/star_trooper/birthdate-speciality-azure-springboot-2i4l

WebApp link : https://birthdate-speciality-service-birthdate-sp-app.azuremicroservices.io

Licence : MIT

View on GitHub

Step 3: Deployment Process using IntelliJ on Azure Spring Boot

After, we are done with building web app and tested by running on localhost. Lets deploy it to azure spring cloud using IntelliJ Azure plugin.
Go to the settings option of IntelliJ(you can see it on top upper right side in the IDE)
Click on plugin option
Search for Azure Toolkit plugin.
Install the plugin and restart the IntelliJ IDE. It will get installed.
Now click on the main project and head towards Azure option. After hovering on Azure you will see many option we will be using Spring Cloud option. But before that we need to connect intelliJ IDE with Azure.
Now click on Azure Spring Cloud.Here you will be asked to sign in with your Azure Account.Many options are available to sign in,you can go with any option.I have signup with OAuth option here.
After done with sign-in. One pop up will be showed on IDE regarding Azure subscription. And IntelliJ and Azure connection will done successfully.
And then go to the azure portal and select Azure Spring Cloud option for creating spring boot service instance for our web app.
Click on create button
Now we will be asked for giving our service instance name and asked to select region.After that click on review and create. Now have patience, let the Azure do the magic.It will take few minutes to deploy our service instance. After our service instance get deployed successfully. Head towards IntelliJ IDE(I suggest restarting IDE before moving to next step).
Now we have service instance. Lets deploy our java spring boot web app on it. Open the option as shown in Step 3.6. And click on Azure Spring Cloud. You will get some pop up below. Select the Service instance created and add the app name by clicking on the + sign.
Now for app we need to select some options. Example below.
Now click on apply and run. The app deployment will start(please dont click on any buttons like run stop app in IDE or else the deployment process will stop and fails)
After few minutes our app will deployed successfully and we will following output in our IDE console.
We can have a look in Azure portal to cross check whether our SpringBoot app is successfully deployed or not.
We can get the link to our springboot app in Application dashboard (And even in IDE console)

Final Output :

Home Page:
Result Page:

Web App link : https://birthdate-speciality-service-birthdate-sp-app.azuremicroservices.io

Yes we have successfully Created our Spring Boot Web Application and deployed it on Azure using Spring Cloud Service🎉🚀.

Resources credit:

Simple Rock Paper Scissors game build using JuliaLang

Atharva Shirdhankar — Mon, 31 Jan 2022 14:34:44 +0000

Hello everyone 👋, in this article📃 I'll be discussing about how I m learning JuliaLang by building mini projects.

Lets start building Rock Paper Scissors game using JuliaLang.
But first we definitely need an IDE or TextEditor for running JuliaLang code.
We can use VSCode with required extension for running JuliaLang code but since I have just started with JuliaLang so I used repl.it here for coding and exploring JuliaLang(its an awesome online IDE try it).

Motivation behind getting started with Learning JuliaLang:

Best part about JuliaLang is that it is easy to learn just like Python.

The execution speed of JuliaLang is similar to C/C++. That means it's fast.

And it is widely used for Data Science , Machine Learning , Deep Learning and even Web Development(And more lot stuff).

And JuliaLang Community is wide & inclusive,if you stuck somewhere while creating any project using JuliaLang. There are many amazing folks to help you. And if are mathematics, bioinformatics or something related to Statistics and Maths or even you are just a Tech Enthusiast join JuliaLang slack channel. You will find many awesome peers who are enthusiast from of the above fields.

Around 200+ JuliaLang packages are present to make your development work more easy.

Complete Code :

# learning julialang basics by creating classical stone paper scissors game


function play_game()
    moves = ["rock","paper","scissor"]
    computer_move = moves[rand(1:3)]

    human_move = Base.prompt("Please enter stone, paper, or scissor")

    print("Rock...")
    sleep(1.0)

    print("Paper...")
    sleep(1.0)

    print("Scissors...")
    sleep(1.0)

    print("Shoot!\n")

    if computer_move == human_move
        print("You tied, please try again")
    elseif computer_move == "rock" && human_move == "scissor"
        print("You lose, the computer won with rock, please try again")
    elseif computer_move == "paper" && human_move == "rock"
        print("You lose, the computer won with paper, please try again")
    elseif computer_move == "scissor" && human_move == "paper"
        print("You lose, the computer won with scissor, please try again")
    else
        print("You won, the computer lost with $computer_move, nice work!")
    end

end

My Learnings from this mini project build:

1) Learned how to write comment in JuliaLang.

# This is how we write JuliaLang comments
# hashtag followed with text you wanted to commented

2) Learned how to print text.

print("Your text here inside double quotes")

3) Learned how to create function(without parameters)

function fun_name()
.
your code here
.
end

Whenever you create function its necessary to tell compiler where to stop by using end keyword in JuliaLang.

4) Learned how to use conditional loop (if-elseif-else loop).

function test(x, y)
           if x < y
               println("x is less than y")
           elseif x > y
               println("x is greater than y")
           else
               println("x is equal to y")
           end
       end

Whenever we use if-else or if-elseif-else conditional loop after the else condition statement we should use end keyword to tell compiler where does the conditional loops ends.

5) Learned about few inbuilt function.

sleep() : Its an inbuilt method of JuliaLang which comes under Base class and we don't need to import package for it. It basically stops execution of code for specified time. The minimum sleep time is 1 milliseconds.

sleep(seconds)

rand() : It picks random element from array or list of elements. And similar to sleep method its an inbuilt method which comes under Base class.

rand(1:3)

Here we randomly selected 1 element from 3 elements inside the collection.

Source :

JuliaLang Docs
Github Repository for mini Projects using JuliaLang
(Thanks @logankilpatrick for providing awesome mini projects repository)

logankilpatrick / Julia-Projects-for-Beginners

Julia Projects for Beginners — Easy Ideas to Get Started Coding in Julia

How I m Learning new Technologies so Quickly and how you can do it too(Open Source Way)?!

Atharva Shirdhankar — Tue, 28 Dec 2021 21:29:19 +0000

When I see myself one year back I was completely confused like how should I learn new things and do some progress in the Tech Field🙁.

But now!!!! when I see back in time currently I m doing great progress and easily learning new technologies😁.

But actually, what I did or steps I took the cause of which I m doing great progress within a year.
Let me tell you how I did it in this article and even how you can do it if you are struggling in Coding or learning new technologies.

Many things helped me learn new technical things but let start this first article let me share with you how Open Source helped me
(More article on How I m Learning new Technologies so Quickly is coming soon...)

Open Source Contribution

My Open Source Journey

I started Open Source Contribution in November 2020 somewhat and I made my first contribution to GitHub-docs as a contributor cause only text and typo were needed to be corrected which was perfect for a beginner like me to get started with open source contribution.

Improve documentation issue no #1034 #1242

StarTrooper08 posted on Nov 10, 2020

Done with the minor fixes for open issue number #1034 .

Why:

What's being changed:

Check off the following:

[ ] All of the tests are passing.
[ ] I have reviewed my changes in staging.
[ ] For content changes, I have reviewed the localization checklist
[ ] For content changes, I have reviewed the Content style guide for GitHub Docs.

View on GitHub

And when I doing my first contribution I was literally confused about what should I do cause I was not familiar with Git and Github.The mechanism of committing and creating pull requests was new to me.
But thanks to the Github docs maintainer team they helped a lot in my first contribution and even I explored and learned about Git and Github on the way.
After my first contribution I did more 2 contributions to GitHub docs that were too related to documentation and typo work.
As I did my 3 contributions I got used to Github's contribution workflow (fork repository, commit changes, create pull request stuff)and even got the confidence to contribute to another project which has actual coding stuff.
I started with contributing to HTML , CSS , javascript codebase projects. Slow and steady I started contributing to Reactjs codebase projects and now currently working on Docker and Android-related issues.

What did I learn from Open Source and by doing contribution to OSS?

The journey of Open Source was amazing I learned so new many things on the way. And not only learned new technologies and frameworks but also made new friends.
The Open Source contribution I did help me to learn different web frameworks like Django, Flask, etc. And frontend library reactJs.
Many times during open-source contribution I came across a codebase that was overwhelming at first. Even came across new technologies I'd never heard of. So by doing Open Source contribution I was learning on the way and I learned those stuff first and I used to implement it by contributing.
By contributing to open-source software I became habitual to dealing with the overwhelming codebase, reading the codebase, and do the changes in the code where required.

And yes if you think how I can those new technologies and do the contribution work.
Just ask for some help in the open-source community. There will surely be someone to help you and guide you if you are stuck somewhere. That's the amazing part,I like about Open Source😃

When you do Open Source Contribution you are gaining experience which will surely help in the future.

Conclusion
In short, I learned a new programming language, new technologies in public and also implemented those learnings on the way and gained some experience.

How you can start with Open Source and learn new things

To get started with open source at first you need to know a few git commands like clone, commit, push. And a little bit familiar with Github's issue, pull request feature. Other advanced concepts of git and Github you will learn on the way by doing contribution.
After learning a few concepts of git and GitHub. On GitHub search for some repositories which are specific for documentation or HTML, CSS, javascript base project and best for beginners to start with open source. Below are Few of them to which I contributed and still contribute

github / docs

The open-source repo for docs.github.com

EddieHubCommunity / BioDrop

Connect to your audience with a single link. Showcase the content you create and your projects in one place. Make it easier for people to find, follow and subscribe.

EddieHubCommunity / EventCalendar

Community events from TwitterSpaces to Live streams to Conferences

JuliaLang / www.julialang.org

Julia Project website
Now search for good first issues in the issue tab.
And work on those issues accordingly
After getting used to with Github workflow(find an issue, do some required changes in code or documentation(text), create pull request and merge your code), I recommend working on the project which you think is quite overwhelming for you or you want to learn programming language search for those projects which include it.
Slow and steady you will learn new programming language or technology and that too efficiently.

(I didn't mention everything in detail about how you can do open source contribution but I m sure you got this😅. My motive behind this article is simple to do open source contribution and learn new things on the way and also gain some experience 🚀)

Thank You for Reading this Article and yes stay tuned for the next part of this blog series by following me.

IoT Commit : IoT Github Action

Atharva Shirdhankar — Wed, 08 Dec 2021 20:08:58 +0000

My Workflow

What does this github action do ?

This action is basically fun IoT base project. It basically connects to the home smart lights with the help of VeSync's python package ,which I have used in this project and whenever someone makes commits on github the lights get on for few mins(Here I have set the timer to 3600s you can change if you want). And after the specified time the lights get automatically off. To make lights on again you have to create commit again.

Few Benefits of the Github Action:

The on and off event of the lights for specified time let you know that this much time has been passed(here it is 3600s). So inshort, this action will work as Alarm or timer for you but little bit interesting one.
To start the lights on again for 3600 seconds(time can be changed) you need to commit code again on github. So you can do your task effectively and quickly.

Submission Category:

Interesting IoT

Yaml File or Link to Code

StarTrooper08 / IoT-Commit

Light-Commit

Home IoT device based Github Actions

Blog : https://dev.to/star_trooper/iot-commit-iot-github-action-369n

View on GitHub

Usage:
Create .github/workflows/main.yml directory in your repository

name: smart light action

on:
  push:
    branches: [ master ]

jobs:
  smart_lights_job:
    runs-on: ubuntu-latest
    name: Turn on smart lights
    steps:
    - uses: actions/checkout@v2

    - name: Trigger lights 
      uses: StarTrooper08/Light-Commit
      with:
        VESYNC_PASS: ${{ secrets.VESYNC_PASS }}
        VESYNC_EMAIL: ${{ secrets.VESYNC_EMAIL }}

Secrets Configuration :

Add 2 parameter(VESYNC email and password) as repository secrets.
You can name the secrets(recommended) as above or different if you used different name don't forget to change it in other yaml code too.

Hardware config : You need to signup on VeSync portal with your email and connect smart light with it(you can also use Android App from playstore).

Add email and password as Repository secrets.

Limitations :

The process only works if your smart lights are connected to VeSync.
Few a times the process quits automatically.
Only few well known smart lights brand can be connected to VeSync.

License

The MIT License

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.

Notify Bot : Github Action + Workflow

Atharva Shirdhankar — Tue, 07 Dec 2021 23:19:32 +0000

My Workflow

Motivation for Building building this Github Action :

If you are Open Source Maintainer or Contributor or a developer working with team which has huge number of members then you have definitely used Slack at one point. And as a developer we even used Github.
Since I m Open Source Contributor and Maintainer many a times I have to find issues and take help regarding those from community members to solve that issue or direct the beginner contributor to proper issue . And mostly I have communicate and collaborate with other maintainer and contributors on Slack so I thought building this action which will surely save time of Maintainers and contributors .

Features:

Greet - When contributor of the project creates pull request a "Thank you" greet is send .
Issue Notification - When someone creates new issue few context like issue title, issue creator/contributor username and link to the github issue is shared on Slack channel.
Issue Notification - When someone creates pull request few context like issue title, pull request creator/contributor username and link to the github issue is shared on Slack channel.

What will this github action do? If I use it in my github project!!

If you are maintainer of project this github action will surely save your time . And let help newbie contributors effectively and discuss them about the following issue on slack. You can direct new contributors to the good first issue and direct them properly.

Submission Category:

Maintainer Must-Haves

Yaml File or Link to Code:

StarTrooper08 / Notify-Bot

Maintainer Friendly Github Actions

Notify-Bot

Features :

Notification: Sends Message on Slack channel when someone create's issue or Pull Request.
Greeting: Greets to the Contributors when they create new Pull Request

Detailed Blog : https://dev.to/star_trooper/notify-bot-github-action-workflow-2676

View on GitHub

How to get and configure Tokens :

To use this action + workflow we need 3 Tokens/API keys/Security keys:
They are as following:

Github Token : You don't need worry about this token since it will be automatically configured by Github.
Tenor gif Token:
Go ahead and visit the tenor gif developer portal and sign up with gmail and get your free api key.
After getting your Tenor Token you can go to your github repository where you want to setup this action then go to settings of that repository .
Search for 'secrets' option. And then click on new repository secrets.
Give it a name and paste the token(eg.name: TENOR_TOKEN value: copied token from tenor gif portal).
Slack App Token:
Go to Slack App portal and click on 'Create an App'

After clicking on 'create an app' you will be asked whether you want to start from scratch or from app manifest we will go for 'from scratch option'
Then one popup will arise asking for app name and to use it in which slack workspace.
Now search for Review scopes something like this option. Click on that button.
And add 2 scopes. Shown in the figure below.
You will see OAuth and Permissions option in the left side bar. Go to that option and scroll little down and click on 'install to workspace' to the workspace(workspace which we selected at the start)

Allow the App to join the workspace.
After this above step you will see your slack app token copy it and store it in repository secrets similar to tenor token.

Lastly invite your app into the slack channel you want.

How to setup this action + workflow on our repository:

After the configuring the token stuff you are just few steps away.
Create .github/workflows/my_action.yml directory.
After that paste this yml code into my_action.yml file.

name: Notify Bot

on:
  pull_request:
      branches: [ master , main ] 
      types: [opened,closed]
  issues:
      types: [opened]


jobs:
  Greet:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
      - uses: StarTrooper08/Notify-Bot
        with:
          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
          TENOR_TOKEN: ${{secrets.TENOR_TOKEN}}


  notifyPR:

    runs-on: ubuntu-latest
    steps:
    - name: Notify slack about PR
      env:
        SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
      uses: abinoda/slack-action@master
      with:
        args: '{\"channel\":\"channel_id\",\"blocks\":[{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"*Github Pull Request:* ${{ github.event.pull_request.title }}\"}},{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"*Contributor Github Username:* ${{ github.event.pull_request.user.login }}\n*Request State:* ${{ github.event.pull_request.state }}\"}},{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"<${{ github.event.pull_request.html_url }}|View Pull Request>\"}}]}'


  notifyissue:

    runs-on: ubuntu-latest

    steps:
    - name: Notify slack about issue
      env:
        SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}
      uses: abinoda/slack-action@master
      with:
        args: '{\"channel\":\"channel_id\",\"blocks\":[{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"*Github Issue:* ${{ github.event.issue.title }}\"}},{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"*Contributor Github Username:* ${{ github.event.issue.user.login }}\n*Issue State:* ${{ github.event.issue.state }}\"}},{\"type\":\"section\",\"text\":{\"type\":\"mrkdwn\",\"text\":\"<${{ github.event.issue.html_url }}|View Issue>\"}}]}'

Note: Wherever I have written channel_id in args of the notifyissue and notifyPR jobs in my_action.yml file put the id of the channel where you have install your slack app. You will get the channel id in the link of slack workspace
https://app.slack.com/client/[workspace ID]/[channel ID]

Congrats You have Successfully added the Github Workflow🎉🚀.

Now you can create new pull request and issue and see the Magic happening ✨!!!

Interesting Python Module PyTube

Atharva Shirdhankar — Fri, 26 Nov 2021 11:07:58 +0000

Hello Everyone ,
In this Interesting Python Module series I will be discussing about interesting python module you must know.
And it will be actually a fun way to learn python by making some micro projects using some interesting python module. So lets started...

In this blog I will be discussing about PyTube. Its an awesome python module which helps us download youtube video!!!

I know ,I know ,you will be surprised by reading this, but yes this module help us download youtube video.

Problem Statement :

As we know youtube video can be downloaded and can be watched offline on mobile(iOS and Android) but on desktop its not possible . Using this python pytube module we can download youtube video on desktop.

So not just waste time and learn how we can write python code to download youtube video.

Before starting with the code part we must have python 2.7 or 3 version installed.

Note :
When you are installing python do check the box which says something like "pip" we will required it for installing pytube module . If we dont do that we will get error during installation of pytube module.

And after python installed properly one more thing need to be installed and that is Pytube Module.
So just open command prompt and type this pip command which will install our module.

pip install pytube

We will get output for the pip command something like this

And I have also created one folder which has initially one python file and in this folder I m going to download youtube video.

Now lets open ide and understand how code will work(I'm using the IDE which comes with python itself)

Code :

# importing the pytube module
from pytube import YouTube


# link of the video to be downloaded
link="https://youtu.be/z-vLtsKvp_4"

yt = YouTube(link)

# getting title of the video
head= yt.title
print(head)

#the streams is pytube class which help filter the content and download just audio or video or both

dl = yt.streams.get_by_itag(22)
#itag is the value given to different video quality stuff.
# For example here itag value 22 means video quality is 720p and we download both audio as well as video format
# Similarly itag value 18 means video quality is 360p and there are many itag value through which you can download differently like just audio or video or both with different video quality.

dl.download()

Output:

On console/python shell we get title of the youtube video printed.

Our video gets downloaded were our python file is present automatically

There is many methods and features to be explored of pytube ,you can read those on official pytube docs.

Pytube : Docs | Github

Idea for Mini Project using Pytube Module :

We can make one mini project using PyTube and Tkinter which will download youtube video of different video quality and create GUI which will ask input from user for "youtube link","video quality",etc.

I m a individual content writer and if you like my work ,do consider buying me a book your small contribution will help be to bring more awesome content.