DEV Community: shamnad-sherief

Flutter’s New Web Dev Proxy: A Cleaner Way to Handle APIs (No More CORS Headaches)

shamnad-sherief — Wed, 25 Mar 2026 06:22:18 +0000

If you’ve ever built a Flutter web app, you’ve probably run into one annoying issue: CORS errors during development.

Traditionally, fixing this meant:

tweaking backend headers
setting up a reverse proxy (like Nginx)
or using messy workarounds

But Flutter recently introduced something that simplifies all of this:

A built-in web development proxy

And honestly, it’s one of those small features that makes a huge difference in day-to-day workflow.

What Is Flutter’s Web Dev Proxy?

Flutter now allows you to define a local proxy using a simple config file:

web_dev_config.yaml

This lets your Flutter web app forward API requests to your backend automatically, without worrying about CORS.

My Setup

Here’s the exact configuration I’m using:

server:
  host: "0.0.0.0"
  port: 8000

  proxy:
    - target: "<target_url>"
      prefix: "/api/"

    - target: "<target_url>"
      prefix: "/files/"

How It Works

This setup means:

Requests to /api/... → forwarded to your backend
Requests to /files/... → also forwarded to your backend

So in your Flutter code, you can simply write:

http.get(Uri.parse('/api/users'));

And Flutter will internally send it to:

<target_url>/api/users

No CORS issues. No extra setup.

Why This Is a Big Deal

1. No More CORS Configuration

You don’t need to:

enable CORS on your backend
install middleware
debug browser errors

3. No External Proxy Needed

Previously, many developers used:

Nginx
webpack dev server proxies
custom scripts

Now Flutter handles it natively.

Optional: HTTPS Support

If you want to test secure environments locally, you can enable HTTPS:

https:
  cert-path: "/path/to/cert.pem"
  cert-key-path: "/path/to/key.pem"

If you’re building Flutter web apps, this is definitely worth adding to your workflow.

Just create a web_dev_config.yaml, define your proxy rules, and run your app.

How I Actually Tracked Down My Internet Lag

shamnad-sherief — Wed, 25 Mar 2026 05:29:09 +0000

I had a frustrating problem: random lag spikes. Sometimes everything was fine, and then suddenly—huge delays, slow loading, unstable connection.

Instead of guessing or blaming my ISP immediately, I decided to trace the problem step by step.

Here’s exactly how I figured it out.

Step 1: I Didn’t Just Ping Google

Most people test like this:

ping google.com

But that only tells you something is wrong — not where.

So I took a different approach.

Step 2: I Tested 3 Different Points

I picked three targets that represent different parts of the network:

ping 100.103.0.1 >> network_log.txt
ping 192.168.1.1 >> network_log.txt
ping 1.1.1.1 >> network_log.txt

Here’s why:

192.168.1.1 → my router (inside my house)
100.103.0.1 → my ISP’s gateway
1.1.1.1 → the internet (Cloudflare DNS)

And I logged everything into a file so I could analyze it later.

Step 3: I Looked for Patterns, Not Just Numbers

From the log , I noticed something interesting:

Most of the time, latency was normal
But occasionally, it spiked massively (hundreds or even thousands of ms)

The key was this:

The spikes were happening on all three targets at the same time

Step 4: That One Observation Changed Everything

This told me something very important.

If only 1.1.1.1 was slow → internet problem
If ISP + internet were slow → ISP problem
But in my case…

Even my router (192.168.1.1) was lagging

That means:

The problem is inside my own network

Step 5: Narrowing It Down Further

Once I knew it was local, the possibilities became much clearer:

WiFi interference
Router struggling under load
Too many devices
Heavy downloads/uploads

And the pattern of spikes pointed strongly to:
bufferbloat (router getting overwhelmed)

Step 6: The Realization

The biggest clue was this:

A router should NEVER have high ping

So when I saw:

300 ms
500 ms
even 600 ms to my own router

That confirmed:

This is not an ISP problem — it’s my router / WiFi setup

What I Learned

This simple method taught me something powerful:

Don’t just test if the internet is slow
Test where it becomes slow

By breaking the network into layers, I was able to pinpoint the issue instead of guessing.

If you're dealing with random lag, try this exact method — it might save you hours of frustration.

Best version manager for Flutter, Meet Puro FVM

shamnad-sherief — Thu, 02 Oct 2025 06:54:37 +0000

If you’ve ever worked on multiple Flutter projects, you already know the pain of juggling different Flutter versions. Maybe one project needs Flutter stable, another depends on beta, and yet another has pinned itself to a specific version like 3.13.6.

Traditionally, you’d spend hours re-installing, re-configuring, or tweaking your IDE settings just to switch versions. That’s where Puro comes in — a tool that makes Flutter version management effortless.

In this post, let’s break down Puro in the simplest way possible. By the end, you’ll know how to:
✅ Install and use Puro
✅ Create isolated Flutter environments per project
✅ Run Flutter commands without confusion
✅ Set up a permanent fix so flutter always points to Puro

What is Puro?

Puro is a Flutter version manager designed to:

Install and switch Flutter versions lightning fast ⚡
Share cached files across projects to save space 💾
Work globally (for your whole system) or per-project (just for one app)
Automatically configure your IDEs (VSCode, Android Studio, IntelliJ) so you don’t have to touch run configurations

In short: Puro saves time, avoids headaches, and makes your workflow consistent.

Installing Puro

Installing Puro is straightforward. For Linux/macOS, run:

curl -o- https://puro.dev/install.sh | PURO_VERSION="1.4.11" bash

For Windows (PowerShell, not as admin):

Invoke-WebRequest -Uri "https://puro.dev/builds/1.4.11/windows-x64/puro.exe" -OutFile "$env:temp\puro.exe"; &"$env:temp\puro.exe" install-puro --promote

After installation, you’re ready to go.

Quick Start: Your First Environment

Puro manages environments — basically, little containers for Flutter versions.

Examples:

# Install the latest stable Flutter
puro flutter doctor

# Create a named environment with stable
puro create foo stable

# Create one with a specific version
puro create bar 3.13.6

# Switch the global Flutter to use "bar"
puro use -g bar

# Switch the current project to use "foo"
puro use foo

👉 Each project can have its own Flutter version. No more conflicts.

Running Flutter Commands

By default, you’ll run Flutter like this:

puro flutter pub get

But typing puro flutter every time gets annoying. Some people even alias it as pflutter.

Luckily, there’s a permanent fix to make flutter always resolve to puro flutter.

Permanent Fix: Shim Executable

Let’s create a fake flutter command that forwards everything to puro flutter:

mkdir -p ~/.local/bin
cat << 'EOF' > ~/.local/bin/flutter
#!/bin/bash
exec puro flutter "$@"
EOF
chmod +x ~/.local/bin/flutter

Then, add it to your PATH:

echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

✅ Now, whenever you run flutter, it’s automatically powered by Puro.
That means flutter pub get is actually puro flutter pub get, and your workflow feels natural again.

Final Thoughts

Puro is a must-have tool for any Flutter developer who works across multiple projects or wants to keep things tidy.

New to Flutter? Start with Puro and you’ll never touch version headaches.
Experienced dev? Save time, bandwidth, and sanity.

So go ahead — install Puro, set up a shim, and enjoy typing just flutter again. 🎉

👉 Learn more at puro.dev.

AngularDart: The Forgotten Sibling of Flutter

shamnad-sherief — Wed, 13 Aug 2025 11:11:57 +0000

Did you know Dart had its own web framework long before Flutter came onto the scene? While Flutter gets all the spotlight today, its lesser-known sibling AngularDart was once Dart’s flagship solution for building scalable web apps.

What is AngularDart?

AngularDart is a structured web framework for building single-page web applications using the Dart programming language. It is a Dart port of Angular (TypeScript)—developed and maintained by Google.

Think of it as:

AngularJS (1.x) → written in JavaScript
Angular (2+) → written in TypeScript
AngularDart → written in Dart

✨ Key Features:

Component-based architecture
Strong static typing with Dart
Two-way data binding
Dependency injection
Routing, templating, and more
Built-in support for large-scale app development

The Origin Story

AngularDart was introduced by Google around 2013–2014, shortly after Dart itself was launched. Its purpose was to provide:

A native Dart solution for building large, maintainable web apps.
A familiar experience for developers coming from AngularJS, but using Dart instead of JavaScript/TypeScript.

It mirrored many of Angular’s concepts like:

Templates
Directives
Services
Component hierarchy

🎯 Why Dart Instead of TypeScript?

At the time, Dart was being positioned as a potential JavaScript replacement (similar to how PyScript is positioned today), and AngularDart was seen as the ideal "killer app" to drive Dart adoption.

Where Was AngularDart Used?

While never mainstream, AngularDart was heavily used inside Google:

AdWords (now Google Ads) team built their UI with AngularDart.
Internal tools and dashboards relied on it due to its scalability and testability.
Supported by Google’s internal toolchain and build system (like Bazel).

🔹 The Rise of Flutter and the Decline of AngularDart

In 2017–2018, Flutter emerged as the star of the Dart ecosystem, offering a fresh approach to UI: one codebase for mobile, desktop, and web (eventually).

🔄 Shift in Focus at Google:

Dart’s purpose shifted from being a JavaScript replacement to powering Flutter.
Google’s resources moved from AngularDart to Flutter Web.
Angular (TypeScript) continued evolving separately, independently of Dart.

🔇 Deprioritization of AngularDart

Official blog updates slowed down.
Documentation stopped evolving.
AngularDart was removed from the Angular main repo and moved to a standalone GitHub repo.
Some previously active Dart packages became archived.

🔹 Is AngularDart Dead?

No — but it’s on life support.

Still works.
Still maintained minimally by the community and Google staff.
Can still be used for web projects.
But: No new major features, limited community support, and Flutter Web is preferred.

🔹 Pros of AngularDart (Then and Now)

✅ Strong typing with Dart
✅ Clean, component-based architecture
✅ Testability
✅ Google-scale performance
✅ Familiar to Angular (TypeScript) devs
✅ Good IDE support via Dart tooling

🔹 Cons

❌ Small community
❌ Few third-party packages
❌ No major updates
❌ Flutter has replaced it for most use cases
❌ Not suitable for modern mobile/web hybrid apps

🔹 Legacy and Lessons

AngularDart may no longer be front and center, but it paved the way for:

Dart’s maturity as a language.
Many design patterns now used in Flutter (e.g., declarative UI, components/widgets).
Google’s commitment to performance and scale with Dart-based tooling.

AngularDart is a fascinating chapter in the Dart ecosystem. While most Flutter developers never encounter it, AngularDart laid much of the groundwork that helped Dart become a serious, scalable language. Understanding its history is not only interesting—it’s a reminder of how developer tools evolve, pivot, and sometimes fade quietly into the background.

AngularDart GitHub Repo

Flutter for iOS: A Beginner’s Guide to Xcode, Signing, and Deployment

shamnad-sherief — Wed, 06 Aug 2025 05:00:51 +0000

If you're a Flutter developer diving into iOS for the first time, Xcode and Apple’s signing system can seem overwhelming. This guide breaks it all down so you can build, run, and upload your app with confidence.

1. What is Xcode?

Xcode is Apple’s official IDE for building iOS apps. Flutter generates an iOS project (ios/ folder) that Xcode compiles and runs.

Why Xcode matters:

Required for running your app on physical iPhones/iPads
Manages code signing, provisioning, and build settings
Needed to build for release and upload to the App Store

2. Project vs. Target in Xcode

Term	Meaning
Project (Runner)	Your whole iOS app workspace (like your Flutter project folder)
Target (Runner)	A specific buildable product (e.g., your app, tests, extensions)

🔍 In Xcode, you'll see both "Runner" project and "Runner" target.

💡 To open your project in Xcode, locate the .xcworkspace file (usually in the ios/ folder) and double-click it, or open it from Xcode via File > Open.

3. What is a Bundle Identifier?

A Bundle Identifier is your app’s unique ID (like com.yourcompany.appname). It’s similar to a package name on Android.

Why it matters:

Must be unique across all iOS apps
Tied to your provisioning profile and certificates
Used by Apple to identify your app in builds and the App Store

Change it in Xcode: Target → General → Bundle Identifier

4. What is Code Signing?

Code signing tells Apple:
"This app was built by a verified developer and is safe to run on devices."

You’ll need:

Certificates (Dev or Distribution)
Provisioning Profiles

Without signing, iOS devices won’t install or run your app.

🧾 5. Certificates (Dev & Distribution)

Certificates are digital IDs issued by Apple.

Certificate Type	Use Case
Development	For testing/debugging on real devices
Distribution	For TestFlight or App Store release

👉 Manage them at: developer.apple.com > Certificates

6. Provisioning Profiles

A Provisioning Profile connects:

Your app (Bundle ID)
Allowed devices
A valid certificate
Enabled capabilities (e.g., iCloud, Push)

Types of Provisioning Profiles:

Type	Use Case	Device Limit	App Store Upload?
Development	Testing on real devices	100/type	❌
Ad Hoc	Internal/manual testing	100/type	❌
App Store	App Store / TestFlight	Unlimited	✅

Use Xcode’s automatic signing unless you need manual control.

7. Xcode's "Signing & Capabilities" Tab

In this tab, you:

Select your Apple Team
Choose your signing certificate & provisioning profile
Enable app features (Push, Background Modes, etc.)

If “Automatically manage signing” is unchecked, you must manually select certificates and profiles — which can lead to errors if mismatched.

8. Flutter Build Modes for iOS

Mode	Purpose	Signing Requirement
Debug	Development / Hot reload	Dev certificate
Profile	Performance testing	Dev certificate
Release	Production build	Dev or Distribution (depends)

Even --release builds can run on devices with a Dev certificate (not App Store).

9. Uploading to App Store or TestFlight

To upload a Flutter app for testing or release:

Run:

   flutter build ipa --release

Open the .xcarchive in Xcode Organizer
Upload to TestFlight or App Store via:

Organizer, or
Transporter (Mac App Store)

Must be signed with an App Store Distribution profile.

10. Registering Devices (UDIDs)

iOS requires device registration for Development and Ad Hoc installs.

Plug your device into Xcode → Trust it → It registers automatically
Limit: 100 devices per year per type (iPhone, iPad, etc.)

11. Build Settings vs. Info.plist

File	Purpose
Build Settings	Compiler flags, signing, Bundle ID
Info.plist	App metadata: display name, version, icons

Change app name in: Info.plist → CFBundleDisplayName
Change product name and bundle ID in Xcode: Target → General → Identity

12. Common Errors & Fixes

Error	What It Means	Fix
No Provisioning Profile found	Xcode can’t sign the app	Enable auto-signing or register device
Attempted to install Beta profile without entitlement	Trying to install release build directly	Use Dev profile or install via TestFlight
Runner has conflicting provisioning settings	Mixed auto/manual signing	Use auto-signing or fix all manually

✅ Final Tips

Use Xcode’s auto-signing to avoid headaches.
Register your device early to test on hardware.
Don't forget: Bundle ID, certificates, and provisioning profiles must match exactly.
Take it slow — iOS has a learning curve, but it’s manageable.

flutter state

shamnad-sherief — Mon, 21 Jul 2025 05:05:42 +0000

Automate Like a Pro: Flutter Meets n8n for Real-Time Hacker News Search + Auto-Posting

shamnad-sherief — Fri, 18 Jul 2025 04:18:48 +0000

In this post, I’ll walk you through how I connected a Flutter mobile app with n8n, a powerful low-code automation tool, to:

Accept a search query from Flutter,
Trigger a workflow via Webhook,
Fetch results from the Hacker News Algolia API,
Return the results back to the app in real-time,

Let’s break it down step by step.

🛠 Step 1: Set Up n8n with Docker

You can get up and running with n8n in seconds using Docker. Here’s the docker-compose.yml I used:

version: '3.8'

services:
  n8n:
    image: docker.n8n.io/n8nio/n8n
    container_name: n8n
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    restart: unless-stopped
    environment:
      - N8N_SECURE_COOKIE=false  # disable secure cookie flag for local development

volumes:
  n8n_data:

Run it:

docker-compose up -d

n8n will be available at http://localhost:5678

🧠 Step 2: Create the n8n Workflow

Here’s what the workflow does:

Receives a POST request from Flutter
Calls the Hacker News API via HTTP Request
Formats the top 5 results using a Function node
Returns them to the mobile app

Workflow Diagram

Hacker News API Used:

GET https://hn.algolia.com/api/v1/search?query=<keyword>

Function Code in `Format Articles` Node:

const results = $json.hits.slice(0, 5).map(hit => ({
  title: hit.title || hit.story_title,
  url: hit.url || hit.story_url
}));

return [{ json: { articles: results } }];

📱 Step 3: Flutter Integration

Here’s the core Flutter code that sends the query and displays the result.

Search Function

Future<void> searchHackerNews(String keyword) async {
  final response = await http.post(
    Uri.parse('http://localhost:5678/webhook/hn-search?query=$keyword'),
    headers: {'Content-Type': 'application/json'},
  );

  final data = jsonDecode(response.body);
  for (var article in data['articles']) {
    print('${article['title']} → ${article['url']}');
  }
}

UI Snippet with `ListView`

ListView.builder(
  itemCount: articles.length,
  itemBuilder: (context, index) {
    final article = articles[index];
    return ListTile(
      title: Text(article['title']),
      subtitle: Text(article['url']),
      onTap: () => launch(article['url']),
    );
  },
)

AI-Powered Personal Travel Planner – Seamless Trip Planning with Runner H

shamnad-sherief — Mon, 07 Jul 2025 06:57:34 +0000

This is a submission for the Runner H "AI Agent Prompting" Challenge

What I Built

I built a personal travel planning agent using Runner H that automates the creation of a customized trip itinerary. With just one prompt, this workflow searches the web for top attractions, accommodations, dining, and local tips, then formats the results into a well-structured Google Doc itinerary.

This solves the common pain point of manual trip research, helping users go from “I want to travel” to “I have a full itinerary ready” — in just a few seconds.

🎬 Demo

📹 Click here to try

📹 Click here to view the demo video

📸 Screenshots and output samples!

How I Used Runner H

Runner H made this process incredibly simple and agentic.

Here’s how the workflow is set up:

Prompt:

Act as my personal travel planner using @tool:WebSearch and @tool:GoogleDocs. I’m planning a [5-day trip to Tokyo, Japan] from [July 25 to July 30, 2025]. Search for the best things to do, must-visit attractions, local experiences, restaurants, and budget-friendly accommodations. Create a detailed day-wise itinerary in a new Google Doc, including: Morning, Afternoon, and Evening plans, Estimated costs (in USD), Recommended transport methods, Restaurant or café suggestions, and Cultural or local tips.

What the AI does:

Uses @tool:WebSearch to gather up-to-date travel data
Organizes it into a 5-day, time-based itinerary
Uses @tool:GoogleDocs to generate and format the travel plan
Saves the doc in Google Drive, ready to print or share

All of this happens through a single natural language prompt — no coding or APIs needed.

🌏 Use Case & Impact

This agent is incredibly useful for:

🧳 Travelers who want a fast, curated plan
🕴️ Busy professionals who don’t have time to research
👨‍👩‍👧 Families planning a group trip
🏢 Travel agencies looking to automate itinerary drafts

Instead of juggling multiple tabs, travel blogs, and spreadsheets, users get a comprehensive day-wise itinerary — curated by AI and formatted for mobile viewing.

🕒 Time saved: At least 3–5 hours per trip

📄 Output: Sharable, printable Google Docs itinerary

Why This Matters

Runner H empowers users to take back their time. In this case, it takes the often stressful process of trip planning and turns it into a structured, ready-to-use document — all powered by a single prompt and a few AI tools.

This isn’t just automation.

It’s AI-assisted exploration

Difference between "min SDK version", "target SDK version" and "compile SDK" version?

shamnad-sherief — Wed, 09 Oct 2024 13:26:00 +0000

TLDR;

Min SDK Version: The min sdk version is the earliest release of the Android SDK that your application can run on. If you set your minsSdkVersion to 21 then the app can be installed on Android 5.0 (Lollipop) and above. Users with older devices, such as those running Android 4.4 (KitKat), won’t be able to install your app.

Target SDK Version: The version your application was targeted to run on. By setting the targetSdkVersion to 33, your app will behave as if it is optimized for Android 13 features when it is running on devices with Android 13. It may run on earlier or later releases, but this is what you were aiming for.

Compile SDK Version: This is the version of the Android SDK that the build system (like Gradle) uses to compile your app’s source code into an APK (or AAB). It dictates which APIs are available during the compilation of your code. The version of Android used by your IDE to build your app into an APK. This means you can use Android API features included in that version of the API (as well as all previous versions). If you try and use API 34 features but set compileSdkVersion to 33, you will get a compilation error. If you set compileSdkVersion to 34 you can still run the app on a API 33 device.

minSdkVersion <= targetSdkVersion <= compileSdkVersion

Usually the compile sdk version and the target sdk version are the same.

What is an SDK?

SDK stands for Software Development Kit. In Flutter, the SDK is a set of tools that you use to build apps for both Android and iOS. The Flutter SDK allows you to write your app in Dart, and it compiles your code to native machine code for both platforms.

Just like in native Android development, Flutter has different SDK versions associated with Android. Each version of Android is assigned an API level. Here’s a quick rundown:

Android 12 = API level 31

Android 11 = API level 30

Android 10 = API level 29

Key SDK Versions in Flutter Development

When you create a Flutter app, you’ll find certain SDK version settings in the configuration files. Here’s what you need to know:
1. minSdkVersion

What is it? The minSdkVersion indicates the lowest Android version your Flutter app can run on. This is important because users with devices running a version lower than your minSdkVersion won’t be able to install your app.

Why is it important? Setting the minSdkVersion correctly allows you to reach a broader audience while ensuring your app runs smoothly on older devices.

How to set it? You can find the minSdkVersion in your android/app/build.gradle file:

      android {
          ...
          defaultConfig {
              ...
              minSdkVersion 21  // This means your app supports Android 5.0 (API level 21) and above
              ...
          }
      }

2. targetSdkVersion

What is it? The targetSdkVersion tells the Android system the highest API level that your app is designed and tested against. This is important for optimizing your app’s behavior according to that particular Android features.

Why is it important? Keeping your targetSdkVersion up to date ensures that your app utilizes the newest Android features and adheres to current best practices. It also helps your app remain compliant with Google Play policies.

How to set it? In the same build.gradle file, you’ll set the targetSdkVersion like this:

      android {
          ...
          defaultConfig {
              ...
              targetSdkVersion 31  // This means your app is optimized for Android 12 (API level 31)
              ...
          }
      }

3. compileSdkVersion

What is it? The compileSdkVersion specifies the Android SDK version used to compile your app’s code. It determines which Android features you can use in your Flutter app.

Why is it important? Setting the compileSdkVersion correctly allows you to access the latest APIs. However, it does not affect the compatibility of your app.

How to set it? Again, in your build.gradle file, you would set it like this:

      android {
          ...
          compileSdkVersion 31  // This allows you to use features available in Android 12
          ...
      }

Putting It All Together

In a typical Flutter app, you’ll define these SDK versions in the android/app/build.gradle file. Here’s an example of what it might look like:

android {
    compileSdkVersion 31

    defaultConfig {
        applicationId "com.example.myapp"
        minSdkVersion 21
        targetSdkVersion 31
        versionCode 1
        versionName "1.0"
    }
}

Other Important Terms in Flutter SDK
Max SDK Version

What is it? The maxSdkVersion can be used to specify the highest version of Android that your app supports. However, it's rarely used and not recommended because it limits the audience.

Example:

      android {
          ...
          defaultConfig {
              ...
              maxSdkVersion 29  // This means your app won't run on Android versions higher than 10
              ...
          }
      }

Best Practices for SDK Versions in Flutter

Set Min SDK Responsibly: Choose a minSdkVersion that allows your app to reach the largest possible audience while ensuring it functions correctly. For instance, if most of your users are on Android 6.0 (API level 23) or higher, you can set the minSdkVersion to 23.
Update Target SDK Regularly: Make it a habit to keep your targetSdkVersion up to date with the latest Android version. This ensures your app remains functional and compliant with Google Play Store policies.
Test Your App on Multiple Versions: Test your app on different devices and emulators to ensure it works well across the versions you’ve set in minSdkVersion and targetSdkVersion.

Conclusion

Understanding SDK versions in Flutter is essential for developing apps that work well across different Android devices and versions. By managing your minSdkVersion, targetSdkVersion, and compileSdkVersion, you can ensure your app is functional, user-friendly, and compliant with modern Android standards.

Start with a suitable minSdkVersion to reach more users, keep your targetSdkVersion updated to utilize new features, and always test your app on various Android versions. Following these guidelines will help you build a robust Flutter application that meets user expectations. Happy coding!

Installing and Managing Different Versions of Node.js with NVM

shamnad-sherief — Thu, 29 Feb 2024 13:14:16 +0000

NVM is a version manager for node.js. Navigating the diverse landscape of Node.js versions can be a daunting task, but with Node Version Manager (NVM), the process becomes effortless.

1. Install NVM: Begin by installing NVM with the provided script:

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.1/install.sh | bash

Alternatively, reopen the terminal or run source ~/.bashrc to apply changes.

2. Confirm NVM Installation: Check the installed NVM version:

nvm --version

3. Install Node.js: Use NVM to install a specific version of Node.js, for example, the latest LTS version:

nvm install --lts

4. Check Node.js Version: Verify the installed Node.js version:

node --version

5. Set Default Node.js Version (Optional): Optionally, set a default Node.js version using NVM:

nvm alias default <node_version>

Replace <node_version> with the desired version number.

Additional Commands:

Install Latest Release of Node.js: To download, compile, and install the latest release of Node.js, use:
```
nvm install node # "node" is an alias for the latest version
```
Install Specific Node.js Version: Install a specific version of Node.js by specifying the version number:
```
nvm install 14.7.0 # or any other version like 16.3.0, 12.22.1, etc
```
List Available Versions: View available Node.js versions with:
```
nvm ls-remote
```
Use Installed Version: Set the installed Node.js version as active:
```
nvm use node
```
Get Path to Installed Executable: Obtain the path to the executable of the installed Node.js version:
```
nvm which 12.22
```

Links for Further Reference:

For detailed instructions, refer to the NVM GitHub repository.
Windows users can download the NVM package from NVM for Windows repository.

I failed to print the consonants

shamnad-sherief — Tue, 07 Feb 2023 04:54:59 +0000

I recently had a coding challenge as part of a recruitment drive, and I was asked to write a program to print the number of consonants in a given string. I was confident in my abilities and decided to use my favourite programming language, Java, to solve the problem.

However, when I ran my code, I encountered an error. I was under a lot of pressure during the coding challenge and my confidence took a hit. I couldn't understand what I had done wrong. I felt embarrassed and ashamed of myself for not being able to solve what seemed like a simple problem.

After the coding challenge, I went home and revisited my code.

public class Consonants {
    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        System.out.println("Enter a string");
        String str = input.nextLine();
        int len = str.length();
        int count = 0;

        for (int i = 0; i < len; i++){

            char c =  Character.toLowerCase(str.charAt(i));
            if( c != 'a' ||
                    c != 'e' ||
                    c != 'i' ||
                    c != 'o' ||
                    c != 'u' ||
                    c != ' ' ){

                count++;
            }
        }
        System.out.println(count);
    }
}

That's when I realized that I had made a logical mistake in my if statement. Instead of using the && operator, I used the || operator, which caused the program to always evaluate to true.

It was a frustrating experience, but I learned a valuable lesson. In high-pressure situations, our thinking can become more focused and narrow, and it can be difficult to see all the possibilities. That's why it's always a good idea to take a break, relax, and come back to the problem with a fresh mind.

I also learned the importance of double-checking my work and paying attention to details, especially in a coding challenge where mistakes can be costly. This experience has motivated me to keep practising and improving my coding skills so that I can perform better in future coding challenges.

2fa on the Command Line

shamnad-sherief — Sun, 05 Feb 2023 14:42:36 +0000

Two-factor authentication (2FA) is a security process in which a user provides two different authentication factors, other than a password to verify their identity. Implementing 2FA can enhance the security of your systems and applications. In this tutorial, we will see how to implement 2FA using the 2fa command line tool.

Step 1: Update the Package List

The first step is to update the package list on your Linux machine. To do this, open a terminal and run the following command:

sudo apt-get update

Step 2: Install GCC Go Compiler

The next step is to install the GCC Go compiler. The GCC Go compiler is required to build and install the 2FA library. To install it, run the following command:

sudo apt install gccgo-go

Step 3: Set GOPATH Environment Variable

The GOPATH environment variable defines the location of your Go workspace. It is used by Go to find the packages and libraries that you need to build your applications. To set the GOPATH environment variable, run the following command:

export GOPATH=$HOME/go

Step 4: Add Go Binary Directory to PATH

The PATH environment variable specifies the directories where the system should look for executable files. To add the Go binary directory to the PATH, run the following command:

export PATH=$PATH:$GOPATH/bin

Step 5: Clone the 2FA Repository

The next step is to clone the 2FA repository developed by Russ Cox. To clone the repository, run the following command:

git clone https://github.com/rsc/2fa.git

Step 6: Change Directory to 2FA

Change the current directory to the 2FA repository using the following command:

cd 2fa

Step 7: Install the 2FA Library

The final step is to install the 2FA library. To install the library, run the following command:

go install -mod=readonly

The -mod=readonly flag ensures that the installed module cannot be modified.

Step 8: Create a Symbolic Link to the 2FA Binary

The 2FA binary is now installed in the Go binary directory specified by the GOPATH environment variable. You can only run the binary from that directory. To make it easier to access the binary from anywhere, we can create a symbolic link to it in the local bin directory. To create the symbolic link, run the following command:

First, create a local bin directory if there isn't exist:-

mkdir -p $HOME/.local/bin

The -p flag tells the mkdir command to create the specified directory if it doesn't exist.

ln -s $HOME/go/bin/2fa $HOME/.local/bin

Now the 2fa configuration is all done and you can access the command from anywhere.

eg:- 2fa -add facebook