DEV Community: Arash

I lost access to my GitHub account!

Arash — Thu, 22 Aug 2024 13:53:27 +0000

Hi. I am Arash and I just lost access to my GitHub account! This happened because I changed my system and I forgot to get those damn recovery codes and now I am locked out.

This post is here to tell anyone out there that this happened and my new account.

My new GitHub account is "Sudo-Arash" or here. I would love to see you there!

The Joy and Necessity of Open Source: Keeping the Community Thriving

Arash — Fri, 17 May 2024 19:00:45 +0000

Why Open Source is Important

Open source is the lifeblood of the tech community. It’s like a massive potluck dinner where everyone brings their favorite dish to share. The core idea is collaboration: sharing code, improving it together, and making it available for anyone to use, modify, and distribute. This spirit of openness and cooperation leads to better software, faster innovation, and a more inclusive environment for developers of all levels.

Innovation at Lightning Speed

When thousands of developers worldwide contribute to a project, it evolves rapidly. Bugs are identified and fixed quickly, new features are added, and improvements are made continuously. This collective effort leads to high-quality software that meets the diverse needs of users. Think of projects like Linux, which powers everything from smartphones to supercomputers, or Apache, which serves a huge portion of the web.

Learning and Mentorship

Open source is a fantastic way to learn and grow as a developer. By diving into real-world projects, you can see how experienced programmers solve problems, manage projects, and write clean, efficient code. Moreover, contributing to open source often means working with mentors who can provide guidance, review your code, and help you improve.

Cost-Effectiveness

For businesses, using open-source software can be a significant cost saver. Instead of paying for expensive proprietary software, companies can use and contribute to free, open-source alternatives. This not only reduces expenses but also gives them the flexibility to customize the software to fit their specific needs.

Why We Need to Keep Open Source Thriving

Community and Collaboration

The open-source community is vibrant and diverse. It’s a place where anyone can contribute, regardless of their background or experience level. This inclusivity fosters a sense of belonging and encourages collaboration across borders and cultures. By supporting open source, we ensure that this community continues to grow and thrive.

Security and Transparency

Open-source software is often more secure than proprietary software. With many eyes on the code, vulnerabilities are spotted and fixed quickly. This transparency builds trust, as users can inspect the code themselves to ensure there are no hidden backdoors or malicious elements.

Freedom and Control

Open source gives users the freedom to use software as they see fit. They’re not locked into a vendor’s ecosystem or forced to pay for upgrades. This control is empowering, allowing individuals and organizations to tailor software to their specific needs.

How You Can Help

Supporting open source doesn’t just mean contributing code. There are many ways to get involved:

Report Bugs: If you encounter issues, report them. This helps maintainers fix problems and improve the software.
Write Documentation: Good documentation is crucial. Help write clear, concise guides to make the software more accessible.
Donate: Many open-source projects rely on donations. Financial support can help cover costs and compensate contributors.
Spread the Word: Share your favorite open-source projects with others. Encourage your friends and colleagues to get involved.

By contributing to open source, you’re not just helping to build better software—you’re supporting a movement that values openness, collaboration, and community. Let’s keep this incredible ecosystem thriving!

Join the conversation on GitHub and other platforms to contribute to the open-source community and help make the world of software a better place for everyone!

Introducing F**kDevTools.js: Secure Your Web Applications

Arash — Fri, 17 May 2024 18:48:41 +0000

Why We Created F**kDevTools.js

In the world of web development, security is paramount. We created F**kDevTools.js to address a common vulnerability: the exposure of sensitive information through browser developer tools. By disabling these tools, we aim to enhance the security of web applications and protect against potential attacks and data breaches.

How It Helps Developers

F**kDevTools.js provides a straightforward solution for developers to prevent unauthorized access to their site's backend through browser developer tools. By disabling right-click, F12, and Ctrl+Shift+I shortcuts, this script minimizes the risk of users inspecting or tampering with the site's code. This added layer of security is especially beneficial for applications dealing with sensitive data.

Installation

Integrating F**kDevTools.js into your project is simple. Follow these steps:

Include the Script: Add the following script to your HTML file:

   <script src="path/to/FuckDevTools.js"></script>

Configuration: Customize the configuration options as needed:

   var disable_right_click = true;
   var disable_f12 = true;
   var disable_csi = true;
   document.onkeydown = function(event) {
       if (disable_f12) {
           if (event.keyCode == 123) {
               event.preventDefault();
           }
       }
       if (disable_csi) {
           if (event.ctrlKey && event.shiftKey && event.keyCode == 73) {
               event.preventDefault();
           }
       }
   }
   if (disable_right_click) {
       document.oncontextmenu = function() {
           event.preventDefault();
       }
   }

Collaboration: Help Us Improve

We believe in the power of community and collaboration. We're calling on developers to contribute to making F**kDevTools.js even better. Whether it's optimizing the script, adding new features, or improving documentation, your contributions are invaluable.

Visit our GitHub repository to get involved. Together, we can create a more secure web for everyone.

By @ghalbeyou on GitHub
https://github.com/GhalbeYou

Don't Use Coding Assistances a Lot!

Arash — Fri, 17 May 2024 12:43:08 +0000

Ah, coding assistants—those magical little helpers that complete your code, correct your syntax, and even write entire functions for you. They're like the fairy godparents of the coding world, waving their wands to transform your pumpkin code into a sparkling carriage. But, before you get too comfortable in your glass slippers, let's talk about why you shouldn't rely on these magical beings too much. Yes, they’re fantastic, but there’s a catch—over-reliance on coding assistances can turn you into a code zombie, forever dependent on their whims.

First off, let’s talk about the classic case of over-reliance. You know, like that one friend who can’t seem to function without GPS even in their own neighborhood. If you lean too heavily on coding assistants, you might find yourself in a similar situation—lost without them. Sure, they save you time and effort, but if you can't write a loop or a function without their help, are you really a coder, or just a code typist?

Next, there's the matter of skill development. Remember when you were a kid, and your parents told you not to use training wheels forever? The same applies here. Coding assistants are like those training wheels. They’re great when you’re starting out, but if you never wean off them, you’ll never know the joy of riding solo. Developing problem-solving skills and coding proficiency takes practice, not just pressing ‘Tab’ to autocomplete.

Let’s not forget learning and memory. Imagine trying to learn a new language by only using Google Translate. Sure, you might get by, but you won't become fluent. Coding works the same way. If you’re constantly relying on your assistant to fill in the blanks, you’ll struggle to remember syntax, functions, and language-specific quirks. And let’s be real, nobody wants to be that person who can’t remember how to write a basic for-loop without looking it up.

Then there's the issue of tool limitations. Coding assistants are good, but they’re not perfect. They can suggest suboptimal or downright incorrect code. It's like having a friend who gives you relationship advice based on rom-coms—they mean well, but the results can be disastrous. Over-relying on these tools without understanding the underlying code can lead to inefficient and buggy programs.

Another thing to consider is your debugging skills. Coding is as much about fixing errors as it is about writing code. If you’ve always got your assistant holding your hand, you might miss out on developing critical troubleshooting skills. It’s like never learning to change a tire because AAA is always a call away. When the time comes, you’ll be stuck on the side of the road—or in this case, stuck with a bug you can’t fix.

Now, let’s talk about creativity and problem solving. Coding without an assistant forces you to think outside the box. It’s like cooking without a recipe—you might make a few mistakes, but you’ll learn to innovate and create something uniquely yours. Over-reliance on coding assistants can stifle this creativity, making you dependent on pre-existing solutions rather than crafting your own.

Think about the satisfaction of achievement. There’s something incredibly rewarding about solving a tough problem on your own. It’s the coder’s equivalent of climbing a mountain or baking a perfect soufflé. Relying too much on assistants robs you of these “eureka” moments. Don’t deprive yourself of that dopamine hit that comes from figuring it out by yourself.

And let’s not ignore the importance of manual practice. Like a musician who practices scales to master their instrument, coders need to practice manually writing code to master their craft. Skipping this crucial step by relying on assistants can leave gaps in your knowledge and skill set, much like a musician who can only play with sheet music but can't improvise.

Remember, coding is a journey, not a destination. Enjoy the process, the mistakes, and the learning. Over-reliance on coding assistants can turn this exciting journey into a monotonous ride on autopilot. It’s the difference between driving a scenic route and being stuck on a conveyor belt—one is an adventure, the other is just a ride.

In conclusion, coding assistants are amazing tools that can boost productivity and ease the learning curve. But, like all good things, they should be used in moderation. Don't let these assistants turn you into a passive participant in your own coding journey. Embrace the challenges, celebrate your successes, and most importantly, keep coding with your own two hands (and maybe a bit of your brain). Happy coding!

I created a react framework!

Arash — Mon, 22 May 2023 10:15:01 +0000

Hello! I have created a React framework called React Legecy. This is my first framework, and it is designed to be simple and fast, specifically optimized for cheap hosting environments.

React Legecy utilizes hashes to determine the current page. Here's how it works:

/#/: This represents the index page.
/#/about: This represents the about page.

The framework includes a 404 page and an error handler to ensure a smooth user experience. Additionally, it features an API handler for handling API requests.

You can find the npm package for React Legecy at: React Legecy on npm.

If you are interested in exploring the framework's source code or contributing to its development, you can find it on GitHub: React Legecy on GitHub.

Thanks for reading!