DEV Community: Jaleel Nazir

Avoid These 6 Common Password Mistakes – Protect Your Accounts Now!

Jaleel Nazir — Wed, 13 Nov 2024 19:56:02 +0000

Top 6 Essential Password Management Tips for All Ages

Use a Trusted Password Manager (Like Google or Apple): Rely on browser-based password managers to store complex passwords securely across devices. This keeps your passwords safe, synced, and easily accessible wherever you log in.
Avoid Confusing, Similar Characters Steer clear of look-alikes: i, I, l, L, 1; o, O, 0; S and 5; Z and 2. Passwords should be memorable yet distinct to avoid typos that cause login frustrations.
Stay Clear of Basic, Easy-to-Guess Patterns Skip obvious choices like “1234,” “abcd,” “password,” or your name, birthdate, phone number, or any personal info. Simple patterns are easily guessed by attackers!
Don’t Reuse Passwords Across Sites Reusing passwords increases your risk across accounts. Keep each password unique, so if one account is compromised, others remain safe.
Enable Two-Factor Authentication (2FA) For added security, enable 2FA whenever possible. This second layer protects you even if someone discovers your password by requiring a time-sensitive code.
Use a Password Generator to Create Strong Passwords Password generators create complex, randomized passwords with numbers, symbols, and mixed cases. Using a generator reduces the temptation to rely on predictable patterns or names.

How we implemented a straightforward post history system at Glynk

Jaleel Nazir — Tue, 12 Dec 2023 13:50:29 +0000

In #Glynk, a community platform enabling users to create social content posts and events, a comprehensive moderation system is implemented to manage user-generated content.

We have a system in place with both an automation script and a team to moderate content. The challenge was to track the edit history of posts, detailing when they were created and the modifications made.

Our main backend and web apps are created with Django. Despite the availability of Django libraries for this purpose, an alternative setup was chosen. The decision was made to create an independent module, separate from the existing ones, to facilitate easy tracking of modifications. At that time, the Post model comprised around 100 fields, but the product requirement was to monitor only a select few.

The chosen solution involved implementing a new MongoDB model:

{
    "post_unique_id": post_unique_id, // Indexed
    "original_post_obj": serialized_post,
    "change_logs": [
        {
            "modified_at": timestamp,
            "modified_by": user_id,
            "serialized_post_obj": serialized_post_obj,
        },
        {
            "modified_at": timestamp,
            "modified_by": user_id,
            "serialized_post_obj": serialized_post_obj,
        }
    ]
}

The "post_unique_id" serves as a unique identifier and is indexed for efficient retrieval. The "change_logs" array stores instances of the post object representing modifications over time.

To view the post details and history, a separate AJAX call was integrated into the moderation console. This call retrieves both the initial and the last modified data, providing a comprehensive view of the post's evolution.

We wrapped up the whole setup — design, backend, and web frontend—in just four days. For the past two years, the system has been strong and reliable, effortlessly managing numerous post modifications. Teamwork played a key role in making it all work seamlessly.

P.S:
We specialise in procuring products and fostering application developments from overseas. Our robust team excels in mobile app development, encompassing Android, iOS, and Flutter platforms, as well as web app and dashboard development.

Our track record includes successfully conceptualising, developing, and delivering applications and infrastructure that have seamlessly scaled from initial stages to serving millions of users.

For further inquiries and detailed discussions, please feel free to connect with us:
https://pods.studio/
https://www.linkedin.com/in/jaleelnazir/

Solving Celery Asynchronous Task Collisions with RabbitMQ vHosts

Jaleel Nazir — Thu, 07 Dec 2023 09:34:00 +0000

I encountered challenges when managing Celery asynchronous tasks across three different codebases: the backend REST API, the frontend web app, and the dashboard app, each residing in its own repository and each app ran on a separate AWS EC2 instance with its dedicated RabbitMQ, and things worked smoothly.

However, when we brought all the apps under a single instance, we ran into issues with Celery asynchronous tasks during development. Tasks collided between apps, causing disruptions. This problem stemmed from using the same RabbitMQ with its default guest account.

Why did it happen?

It occurred because the codebase was from 2013, and during fast development sprints, it was easier and faster to work on separate repositories and instances.
We directly used Python functions to call Celery with .apply_async and .delay, without using the async call with topic and queue.

The RabbitMQ vHosts

To address this, we implemented a simple yet effective solution: creating separate virtual hosts (vHosts) for each app within one RabbitMQ instance.

Key Takeaways

1. Password Pattern Management

Ensuring a correct password pattern (devoid of characters like oO0|.,@ ‘ “) became pivotal. Initially, RabbitMQ’s guest account didn’t require credentials. However, the shift to separate vhosts and vhost users made credentials indispensable, emphasizing the need for legible connection URL formats.

2. RabbitMQ Vhost Implementation

The introduction of RabbitMQ vhosts added an additional task for our DevOps team. Managing vhost setup and credentials became an essential step. Despite the extra maintenance, the clarity it brought to connection URLs justified the effort.

3. Reduced AWS Costs

Consolidating from three instances to one yielded significant reductions in AWS costs. The average cost shrunk from 3x to 1x, offering tangible savings.

Incorporating Connection URL in Code
To enhance readability and maintain a secure connection, we implemented the following in our code:


# Constructing Connection URL with Vhost Information 
AMQP_URL_AND_PASSWORD = 'amqp://vhost_user:vhost_password@' + str(os.environ.get('RABBITMQ_IP')) + ':5672/vhost_name'

This addition ensured a clear and secure connection URL, aligning with our strategy of effective RabbitMQ and Celery management.

Adding Vhost and User via RabbitMQ Commands
For readers looking to replicate our setup, the following commands can be used to add a vhost and user to RabbitMQ:


# Adding a new vhost for the web app Celery instance 
sudo rabbitmqctl add_vhost <vhost_name>
# Creating a new user for the web app Celery instance with a secure password 
sudo rabbitmqctl add_user <vhost_user> <vhost_password>
# Setting permissions for the new user on the created vhost 
sudo rabbitmqctl set_permissions -p <vhost_name> <vhost_user> ".*" ".*" ".*"

These commands help establish a segregated environment for the web app Celery instance, enhancing security and manageability.

Conclusion

Our experience in merging three projects into a single instance wasn’t without challenges. The emergence of async task collision issues prompted a reevaluation of our approach. The adoption of RabbitMQ vhosts provided an effective solution, enhancing management, security with credentials, and driving substantial cost savings. This journey underscores the importance of addressing fundamental infrastructure concerns, even during rapid development sprints.

P.S:

We specialize in procuring products and fostering application developments from overseas. Our robust team excels in mobile app development, encompassing Android, iOS, and Flutter platforms, as well as web app and dashboard development.

Our track record includes successfully conceptualizing, developing, and delivering applications and infrastructure that have seamlessly scaled from initial stages to serving millions of users.

For further inquiries and detailed discussions, please feel free to connect with us:

https://pods.studio/

Utilizing Root View Controller in iOS Development

Jaleel Nazir — Wed, 11 Oct 2023 12:59:31 +0000

In iOS development, the strategic use of root view controllers can significantly enhance the user experience and streamline your app's navigation flow. Root view controllers serve as pivotal points within the application, allowing you to control the display of content based on various scenarios.

Separating Application Flow

Non-logged-in Users: Before a user logs in, root view controllers can be employed to present essential screens such as splash screens, login screens, app introductions, or any other preliminary content that sets the stage for the user's journey.
Logged-in Users: Once a user successfully logs in, root view controllers help transition to the core functionality of your app. This can include displaying the app's main home screen.
Other Custom Features: In this context, root view controllers can handle scenarios like subscription expiration, enforcing updates, or guiding users through onboarding experiences.

Addressing Common Issues

Performance Optimization: By efficiently managing the presentation and dismissal of view controllers through root view controllers, you can minimize performance bottlenecks. This can help prevent issues like excessive memory usage, CPU overheating, and sluggish app performance.
Correct Screen Display: Root view controllers provide a reliable way to track the current front-facing view controller. This ensures that the correct screen is displayed to the user, even when navigating back or undergoing changes in the navigation stack.

Helper Extensions

Opening Controllers from Cells or Views: Root view controllers allow you to open new controllers from within table view cells, collection view cells, or custom views, expanding your app's interactivity.

extension UIApplication {
    class func topViewController(controller: UIViewController? = UIApplication.shared.keyWindow?.rootViewController) -> UIViewController? {
        if let navigationController = controller as? UINavigationController {
            return topViewController(controller: navigationController.visibleViewController)
        }
        if let tabController = controller as? UITabBarController {
            if let selected = tabController.selectedViewController {
                return topViewController(controller: selected)
            }
        }
        if let presented = controller?.presentedViewController {
            return topViewController(controller: presented)
        }
        return controller
    }
}

// How to use
if let vc = UIApplication.topViewController() {
    vc.openGuestLoginPrompt()
}

Handling Notifications: You can use root view controllers to respond to notifications by presenting or opening relevant view controllers, ensuring a seamless user experience.
Diverse Navigation Techniques: While presenting and dismissing view controllers and pushing and popping view controllers are common navigation techniques, root view controllers enable you to explore alternative methods to open screens, enhancing user engagement.

In Conclusion

Mastering the use of root view controllers is a valuable skill for iOS developers. They act as gatekeepers, guiding users through your app's various states and scenarios. By leveraging root view controllers effectively, you can improve performance, maintain proper navigation, and offer a polished and responsive user experience.