DEV Community: Ranjeet Singh

From Procrastination to Progress: My Tech Journey Through 2024 and Beyond

Ranjeet Singh — Mon, 06 Jan 2025 22:02:38 +0000

This is a submission for the 2025 New Year Writing challenge: Retro’ing and Debugging 2024.

Reflecting on 2024, I finally confronted my JavaScript fears. For a long time, its many flavors felt like a maze with too many twists and turns. Then came TypeScript, illuminating the path. Suddenly, working with ReactJS + TypeScript was like fitting together the perfect puzzle pieces. This revelation also propelled me into Android development, where Jetpack Compose made perfect sense, thanks to my newfound understanding of React components.

Achievements:

Mastering TypeScript: Embracing TypeScript brought clarity and structure to my JavaScript projects.
Expanding to Android Development: Leveraging my React knowledge, I dove into Jetpack Compose and Android development.
Tackling Procrastination: The biggest bug I squashed this year was procrastination, which unlocked a world of possibilities.

Lessons Learned:

Embracing New Languages: TypeScript showed me the power of typed languages and their ability to enhance code quality.
Cross-Platform Development: Understanding React components helped in grasping Jetpack Compose, highlighting the value of transferable skills.

Challenges Faced:

Overcoming Procrastination: Realizing that procrastination was holding me back and finding ways to tackle it.
Navigating JavaScript's Ecosystem: Initially, the various flavors of JavaScript felt overwhelming, but TypeScript provided much-needed structure.

Compiling 2025

Looking ahead to 2025, my primary goal is to keep procrastination at bay and continue expanding my skills.

New Skills to Learn:

Deepening TypeScript Knowledge: I plan to become even more proficient in TypeScript and explore its advanced features.
Android Development: Further developing my skills in Android, specifically focusing on Jetpack Compose.
Learning Rust: Exploring Rust for its performance and safety features, and adding it to my tech stack.

Side Projects to Pursue:

Building Cross-Platform Apps: Creating projects that leverage both my web and mobile development skills.
Open Source Contributions: Contributing to open-source projects, especially those using TypeScript, React, or Rust.

Career Aspirations:

Leadership Roles: Aiming to take on more leadership roles within my team, guiding projects and mentoring junior developers.
Continuous Learning: Maintaining a habit of continuous learning and staying updated with the latest trends and technologies.

Predicting 2025

As I look ahead, 2025 promises to be an exciting year in tech. Here are my predictions:

Trend Analysis:

Rise of Rust: Rust will gain more traction due to its performance and safety features, becoming a go-to language for systems programming.
WebAssembly (Wasm): The adoption of WebAssembly will grow, allowing developers to run code at near-native speed in the browser. This will open up new possibilities for web development.

Specific Tools and Technologies:

MLOps: The integration of machine learning operations will bridge the gap between model creation and deployment, making AI more accessible and manageable.
Serverless Architecture: Serverless will continue to simplify scalability and reduce infrastructure management, becoming a staple in modern development practices.
AI-Enhanced Developer Tools: Expect more AI integration in developer tools, from code auto-completion to intelligent debugging, making our lives easier and our code better.

Personal Feelings About the Predictions:

I’m particularly excited about the potential of WebAssembly and Rust. These technologies could revolutionize how we think about performance and safety in both web and systems development.

The continued growth of AI in developer tools is something to watch. It's fascinating to see how AI can enhance productivity and streamline the development process.

2025 is shaping up to be a year of innovation and growth. Here's to fewer bugs, less procrastination, and more breakthroughs! 🚀

Bank Search-engine using MongoDB and Django

Ranjeet Singh — Tue, 11 Jan 2022 22:16:37 +0000

Overview of My Submission

A simple minimalist web page to search Bank info using IFSC code.

Django (Backend)
HTML/CSS/JavaScript (Frontend)
MongoDB (DB - used pymongo to connect Atlas & Django)

Submission Category:

Choose Your Own Adventure

Link to Code

techonerd / BankSearch

A simple search page to get Bank details using IFSC code.

BankSearch

A simple bank search tool.

Backend: Django

Frontend: HTML, CSS, JavaScript

DB: MongoDB (pymongo)

View on GitHub

Additional Resources / Info

source-code : https://github.com/techonerd/BankSearch

live-preview : https://banksearchs.herokuapp.com/

CI pipeline for Django Project

Ranjeet Singh — Mon, 06 Dec 2021 07:32:37 +0000

My Workflow

Have Django project setup and test cases written to be used to check continuous integration and checking code against flake8.

With this in mind follow these steps:

Create you Django project as usual django-admin startproject <project_name> .
Run your project with python manage.py runserver .
Initiate git in your project if not have it yet with git init .
Configure sensitive data like SECRET_KEYS and DEBUG_VALUE as environment variable in github repository.

Now our project is all setup and running, we will take care of CI on each commit PUSH on github repository.

Submission Category:

Wacky Wildcards

Yaml File or Link to Code

Add the .yml file as follows .github/workflows/name.yml in the project. For more information refer to the official docs

name: Django CI
on:
  push:
    branches:
      - '*'
      - '*/*'

jobs:
  build:

    runs-on: ubuntu-latest
    strategy:
      max-parallel: 4
      matrix:
        python-version: [3.7, 3.8, 3.9]

    steps:
    - uses: actions/checkout@v2
    - name: Set up Python ${{ matrix.python-version }}
      uses: actions/setup-python@v2
      with:
        python-version: ${{ matrix.python-version }}
    - name: Install dependencies
      run: |
        python -m pip install --upgrade pip
        pip install -r requirements.txt
    - name: Run Tests
      env: # environment variable
        SECRET_kEY: ${{ secrets.SECRET_KEY }}
        DEBUG_VALUE: ${{ secrets.DEBUG_VALUE }}

      run: |
        python manage.py test
    - name: Lint with flake8
      run: |
        pip install flake8 
        # stop the build if there are Python syntax errors or undefined names
        flake8 . --count --select=E9,F63,F7,F82 --show-source --statistics
        # exit-zero treats all errors as warnings. The GitHub editor is 127 chars wide
        flake8 . --count --exit-zero --max-complexity=10 --max-line-length=127 --statistics

We can run CI for various python versions.
We can access secret variables as ${{secrets.<VARIABLE_NAME>}} .

Additional Resources / Info

Github repository

under MIT license

Collaborators

@dkaiamit @kido-kit-kat

Happy coding, happy hacking ^^