DEV Community: Aman Jaswal

How to turn your handwriting into a font in 60 seconds (Open Source)

Aman Jaswal — Tue, 23 Dec 2025 10:15:15 +0000

Have you ever wanted to type with your own handwriting? Most font software is too complicated. I built an open-source tool called Image-to-TTF, to make it as simple as: Draw, Upload, Type.

Here is how you can create your own .ttf font file in minutes.

Step 1: Draw Your Letters

The secret to a good font is a consistent grid.

Get a Grid: Use a piece of graph paper or draw a series of square boxes on a plain white sheet.
Draw: Write one letter (A, B, C…) or symbol inside each box.
Crop: When uploading, crop the image to exact outer border.
Tip: Use a black marker or a dark pen. High contrast makes the font look much cleaner!

Sample Image:

Step 2: Upload Your Image

Once your sheet is full, it’s time to go digital.

Snap a Photo: Take a clear, top-down photo of your paper.
Open in Collab: Go to Github and open the .ipynb file in google collab.
Upload: Drop your .jpeg image in google collab folder directory and upload.
Rename: Rename the file to input_image.jpeg .
The Magic: The tool automatically finds the boxes, traces your handwriting, and converts those shapes into vectors.

Step 3: Download & Type

Within seconds, the tool will bundle everything into a single file.

Download: Click the button to get your LogoFont_Complete_Family.ttc file.
Install: * Windows: Right-click the file > Install. * Mac: Double-click > Install Font.
Use it: Open Word, Photoshop, or any app, select your font, and start typing!

Why is this Open Source?

I built this tool because of a challenge from my brother. He’s a designer working on digitizing a tribal script, trying to bring a traditional writing system into the modern digital world. DM him for designs link

Become a member

He needed a way to go from paper sketches to a functional font file without the complexity of professional type-design software. So, I built an open-source tool to do exactly that.

Preserving a language or a script shouldn’t be locked behind a paywall. By making this tool open source, I want to help:

Designers working on cultural preservation.
Language enthusiasts digitizing rare scripts.
Creatives who just want a font made of their own handwriting.

Get Involved

This project is in its early stages. Whether you are a developer who can improve the image processing or a designer with feedback on the font quality, I’d love your help.

Please DM me on

Check out the project on GitHub: Link to the Repo 🚀

High-Paying, Low-Competition Languages for Software Engineers

Aman Jaswal — Fri, 12 Sep 2025 14:17:04 +0000

The software engineering landscape is more competitive than ever, especially for generalist and entry-level roles. However, a massive gap exists in the market for specialized skills, creating an opportunity for experienced software engineers to earn high salaries with significantly less competition.

This article explores four key programming languages that are in high demand but have a limited talent pool. We'll examine their salary potential, competition level, and ideal use cases to help you choose your next career move.

The Current Market: The Paradox of High Demand and High Competition

While the demand for software engineers remains high, so does the competition for roles in popular languages like Python, Java, and JavaScript. The talent pool for these languages is vast, leading to saturated job markets, especially for junior and mid-level positions. Companies are correcting for past overhiring and are increasingly prioritizing "job-ready" specialists who can deliver immediate value, rather than generalists.

This is where the opportunity lies. By focusing on niche, high-value languages and technologies, you can position yourself as an expert and command a premium salary.

The Top Contenders: Go and Rust

Go and Rust are not "new" languages, but they have firmly established themselves as the top earners in the software development world due to their specific strengths.

1. Go (Golang)

Go is a statically typed, compiled language developed by Google. It's known for its simplicity, fast compilation, and excellent support for concurrency.

Salary & Demand: Go developers are among the highest paid globally. In the U.S., average salaries range from $115,000 to $180,000 for experienced developers. In India, salaries are highly variable but can be exceptionally high for senior talent, with some reaching ₹30 lakhs per year in major tech hubs. The job market has a high demand for Go developers, and there's a noted scarcity of skilled talent, making competition significantly lower than for mainstream languages.
Best For: Cloud Infrastructure, DevOps, and Microservices. Go is the language of choice for building scalable, high-performance backends. If you're passionate about systems, networking, and building the back-end services that power modern applications, Go is a fantastic choice. Major companies like Uber and Dropbox have successfully migrated their core services to Go.
Learning Curve: Relatively easy. The language's small syntax and clear design make it quick to pick up for a seasoned software engineer.

2. Rust

Rust is a systems programming language focused on performance, memory safety, and concurrency. It's often seen as a modern alternative to C++.

Salary & Demand: Rust consistently tops salary surveys, often commanding the highest average salaries. A Rust developer in the U.S. can expect to earn between $135,000 and $200,000 or more. In India, salaries are even more impressive, with some senior engineers earning ₹97 lakhs per year. The competition for Rust roles is very low because the language has a reputation for being difficult to master.
Best For: High-Performance Computing, WebAssembly, and Blockchain. Rust's key selling point is its guaranteed memory safety without a garbage collector, which is crucial for systems where every byte of memory and CPU cycle matters. It is a dominant force in the Web3 space and is increasingly being used to build performant components for web and desktop applications.
Learning Curve: Steep. Rust's strict compiler and unique ownership model can be challenging for developers new to systems programming. However, mastering it is a strong signal of expertise to employers.

The Next Hype: Emerging Languages with Massive Potential

For those willing to take a higher risk for potentially even greater rewards, two new languages are capturing the attention of the tech world. They have virtually zero competition but are just beginning to build their ecosystems.

3. Mojo

Mojo is a new language that combines the ease of Python with the raw power of systems programming. It is specifically designed for the AI/ML and High-Performance Computing (HPC) space.

Salary & Demand: As an emerging technology, there is limited but exceptionally high-paying demand. Early salary data shows ranges from $140,000 to over $200,000. Competition is minimal, as the language is still in its early stages.
Best For: Artificial Intelligence and Machine Learning. If you are a data scientist or AI engineer, Mojo is designed to address the "two-language problem" of using Python for scripting and C++ for performance. It offers a direct pathway to significantly accelerate your AI models.
Learning Curve: Moderate. If you already know Python, picking up Mojo's syntax will be a breeze. The challenge lies in mastering the performance-critical aspects of the language.

4. Zig

Zig is another systems-level language that is a direct competitor to C and C++. It aims to provide the best features of C while solving its major pitfalls, such as memory errors and compiler inconsistencies.

Salary & Demand: Like Mojo, Zig is in its infancy in the job market, but early signals point to high salaries. It is already being used in a few key projects, and the demand is for highly specialized roles. Salaries range from $62,000 to over $165,000.
Best For: Embedded Systems, Operating Systems, and Game Development. Zig is for the true low-level enthusiast. It offers a unique combination of manual memory management, explicit error handling, and a powerful build system that makes it perfect for building fast, reliable, and portable software.
Learning Curve: Steep. If you are not already an expert in low-level systems programming, Zig will require a significant time investment.

The Verdict: A Roadmap for Your Career

Choosing a language depends on your risk tolerance and long-term career goals. Here's a suggested roadmap to help you decide:

For a Quick Win and High Salary: Start with Go. The learning curve is manageable, the ecosystem is mature, and the demand is incredibly strong, especially in the booming cloud and DevOps sectors. You can quickly become a valuable asset to any company.
For a Long-Term Investment with Maximum Reward: Choose Rust. If you are prepared for a challenge and want to position yourself in the highest-paying niche in software development, Rust is the way to go. The investment in learning will pay off handsomely in the long run.
For the AI/ML Innovator: Look into Mojo. If you are already working in data science or AI, Mojo is the most direct path to boosting your salary and career prospects. It's a high-risk, high-reward bet on the future of AI.
For the Low-Level Systems Enthusiast: Explore Zig. This language is for a very specific type of engineer who loves working with hardware and low-level systems. If that's your passion, Zig offers a rewarding and high-paying path with very little competition.

Free QR code generators are no more free

Aman Jaswal — Wed, 03 Sep 2025 13:35:55 +0000

Free QR Code Generators Are No More Free: A Developer's Frustration

Read this article on medium

Why we built our own open-source QR generator and why you should care about digital privacy

The Promise That Was Too Good to Be True

Remember when "free" actually meant free? Those days seem to be fading fast in the world of QR code generators. What started as a simple need—generating a QR code for a project—turned into a rabbit hole of privacy concerns, hidden charges, and data harvesting that ultimately drove us to build our own solution: Free QR Creator.

The Current State: "Free" with Hidden Costs

Our research into the current QR code generator landscape reveals a troubling pattern. While many platforms still advertise themselves as "free," the reality is far more complex:

The Freemium Trap

Several QR Code generators adopt a freemium business model to draw customers, providing basic capabilities for free or at a minimal cost. This model sounds reasonable until you realize what "basic capabilities" actually means:

Limited QR codes per month (often as low as 5-10)
Watermarked outputs that scream "amateur"
No customization options without upgrading
Forced registration for basic features
Analytics tracking enabled by default

The Data Collection Reality

Perhaps most concerning is how your data becomes the product. Modern QR generators are sophisticated data collection machines:

User behavior tracking: QR Code AI's tracking platform allows you to monitor scans by city, country, and even device type, offering detailed insights on where and how your QR codes are being scanned.
Personal information harvesting: Many require email registration, phone numbers, and business details
Usage analytics: Every QR code you generate becomes a data point in their analytics engine
Third-party sharing: Privacy policies often include broad clauses about data sharing with partners

The Analytics Justification

Providers justify this data collection by offering "valuable analytics." A close association with Dynamic QR Codes is the detailed analytics they offer. It provides invaluable insights into your QR Code's performance, user engagement, and other essential metrics, empowering you to make data-driven decisions. But here's the catch—you're paying for these analytics with your privacy, and often you don't even want them.

What Developers Actually Need

As developers, our QR code needs are often straightforward:

Generate a QR code quickly without registration
Download it in multiple formats (PNG, SVG, PDF)
Customize basic properties (size, colors, error correction)
No tracking or analytics for simple use cases
Open source transparency about what the code actually does

Most commercial generators over-engineer the solution, adding layers of complexity, tracking, and monetization that developers simply don't need.

The Privacy-First Alternative

Frustrated by these limitations, we built Free QR Creator with a simple philosophy: truly free, truly private, truly open source.

What Makes It Different

No registration required: Generate QR codes immediately
No data collection: Your inputs aren't stored or tracked
No limits: Generate as many QR codes as you need
No watermarks: Clean, professional outputs
Open source: Full transparency—view the code
Multiple formats: PNG, SVG, and PDF downloads
Customization options: Colors, sizes, error correction levels

Technical Implementation

Built with modern web technologies:

Next.js for optimal performance
Client-side generation: QR codes generated in your browser, not on our servers
No backend data storage: Nothing to compromise because nothing is stored
Responsive design: Works on desktop and mobile
Fast deployment: Hosted on Vercel for global CDN performance

The Broader Privacy Implications

This isn't just about QR codes—it's about the broader trend of "privacy erosion by convenience." When we accept that "free" services require giving up our data, we normalize surveillance capitalism in our development workflows.

For Individual Developers

Every time you use a tracking-enabled QR generator:

Your project details become part of someone's database
Your usage patterns are analyzed and potentially sold
You're contributing to profiles that follow you across the web
You're setting precedent that this trade-off is acceptable

For Teams and Companies

The implications are even more serious:

Client confidentiality: QR codes for client projects shouldn't be tracked
Competitive intelligence: Your QR usage patterns reveal business strategies
Compliance issues: GDPR, CCPA, and other regulations may be violated
Security concerns: Third-party tracking creates additional attack vectors

The Developer Community Response

The good news? Privacy-focused secure QR code generators are emerging as developers recognize these issues. The bad news? They're still too rare, and many developers remain unaware of the privacy trade-offs they're making.

What We Can Do

As Individual Developers

Audit your tools: Check the privacy policies of services you use regularly
Choose open source: When possible, use transparent, open-source alternatives
Self-host when practical: For sensitive projects, run your own instances
Share privacy-focused alternatives: Help colleagues discover better options

As a Community

Build alternatives: The barrier to entry for many tools is lower than we think
Support privacy-first projects: Star, contribute, and promote open-source alternatives
Educate peers: Share knowledge about privacy implications of common tools
Demand better: Let commercial providers know that privacy matters to you

Looking Forward

The QR code generator space is just one example of how "free" services have evolved to extract value through data collection rather than direct payment. As developers, we have both the skills and responsibility to build better alternatives.

Our Free QR Creator is a small step in this direction, but the broader movement toward privacy-respecting development tools needs to grow. Every developer who chooses a privacy-first alternative sends a signal about what we value as a community.

Try It Yourself

Ready to generate QR codes without the privacy trade-offs? Try our tool at https://free-qr-creator.vercel.app/ and experience what "actually free" feels like.

The source code is available on GitHub—because transparency shouldn't be a premium feature.

What other "free" tools have you discovered aren't actually free? Share your experiences and let's build a directory of truly privacy-respecting alternatives for developers.

Technical Details

For developers interested in the implementation:

QR generation: Uses the qrcode library for client-side generation
No server-side processing: Everything happens in your browser
No analytics: Not even basic visit tracking
Progressive Web App: Install it locally for offline use
Performance optimized: Lazy loading, efficient bundling, minimal dependencies

Ready to fork it? The repository includes detailed setup instructions and contribution guidelines.

Why Smart Lawyers Are Switching to EaseLaw

Aman Jaswal — Tue, 02 Sep 2025 12:06:56 +0000

EaseLaw: The Legal Professional's Secret Weapon for Case Management Excellence

Transform chaos into clarity with AI-powered legal case management

The Legal Practice Revolution You've Been Waiting For

Picture this: It's 11 PM, and you're frantically searching through stacks of papers and endless email threads, trying to find that crucial document for tomorrow's hearing. Your client called earlier asking about their case status, but you couldn't give them a clear answer because the information was scattered across multiple systems. Sound familiar?

Meet EaseLaw – the game-changing case management application that's about to revolutionize how legal professionals organize, track, and manage their cases.

Why you should try EaseLaw

🎯 Complete Case Organization at Your Fingertips

Gone are the days of juggling multiple spreadsheets, sticky notes, and filing cabinets. EaseLaw provides a centralized hub where every case detail lives in perfect harmony. From initial client consultation to final verdict, your entire case lifecycle is organized, searchable, and accessible 24/7.

📈 Visual Case Timeline That Tells Your Story

Every case has a story, and EaseLaw helps you tell it clearly. Our intuitive timeline feature maps out your case's journey with precision:

Key milestones and deadlines
Court appearances and filing dates
Client meetings and communications
Document submissions and responses

See your case progress at a glance and never miss another critical deadline.

🤝 Client Portal That Builds Trust

Transform client relationships with unprecedented transparency. Your clients can:

View real-time case status updates
Access important documents securely
Track case progress without constant phone calls
Stay informed with automated notifications

Happy clients mean more referrals and a thriving practice.

🔔 Smart Notifications That Keep You Ahead

Our intelligent notification system ensures nothing falls through the cracks:

Upcoming court dates and deadlines
Filing reminders and statute limitations
Client meeting schedules
Custom alerts for case-specific milestones

Stay proactive, not reactive.

📝 Powerful Documentation & Notes System

Capture every detail that matters with our robust documentation features:

Secure document storage and organization
Quick note-taking during client calls
Case-specific annotations and reminders
Easy document sharing with clients and colleagues

The Technology That Powers Your Success

Built with cutting-edge technology, EaseLaw combines the reliability you need with the innovation you want:

🤖 AI-Powered Insights: Get intelligent case summaries and strategic recommendations
☁️ Cloud-Based Accessibility: Access your cases from anywhere, anytime
🔒 Enterprise-Grade Security: Your client data is protected with industry-leading encryption
📱 Modern, Intuitive Interface: Designed for lawyers, by legal technology experts

Real Benefits, Real Results

For Solo Practitioners:

Compete with larger firms using enterprise-level tools
Manage more cases without hiring additional staff
Provide superior client service that builds reputation

For Law Firms:

Standardize case management across all attorneys
Improve collaboration and knowledge sharing
Reduce administrative overhead and increase billable hours

For Clients:

Stay informed about their case progress
Access documents and updates anytime
Experience transparent, professional service

Join the EaseLaw Beta Community

We're looking for forward-thinking legal professionals to join our beta testing community and help shape the future of legal case management.

What's in it for you?

✅ 100% FREE access during the beta period
✅ Direct input on feature development
✅ Priority support from our development team
✅ Exclusive lifetime discounts when we launch commercially
✅ Early access to new features and capabilities

Your Practice, Elevated

Don't let outdated case management hold your practice back. Join hundreds of legal professionals who are already experiencing the EaseLaw difference.

Ready to transform your legal practice?

🚀 Start Your Free Trial – No credit card required

📧 Questions? Contact our team for a personalized demo

🌟 Follow us for legal tech insights and product updates

What Beta Testers Are Saying

"EaseLaw has completely changed how I manage my practice. My clients love the transparency, and I love the organization. It's like having a personal assistant that never sleeps."
– Sarah M., Family Law Attorney

"The timeline feature alone has saved me countless hours of case preparation. Everything is visual and logical – exactly what busy lawyers need."
– Michael R., Criminal Defense Lawyer

About EaseLaw

EaseLaw is a next-generation legal case management platform designed specifically for modern law practices. Built with advanced AI technology and user-centric design, we're committed to helping legal professionals deliver exceptional client service while growing their practice efficiently.

Ready to experience the future of legal case management?

Get Started with EaseLaw Today →

EaseLaw – Because your clients deserve clarity, and you deserve efficiency.

The Secret Weapon: AI as a "Meta-Tool" and Firebase Studio

Aman Jaswal — Mon, 01 Sep 2025 19:02:46 +0000

You've heard about using AI for code completion and debugging. That's table stakes now. My approach was different. I didn't just use AI to help my users; I used AI to help me build the application itself. This is where tools like Firebase Studio became an absolute game-changer.

Think of it as a meta-tool. I used AI to:

Accelerate my boilerplate: From setting up the initial server to handling authentication flows, AI-powered assistants helped me generate the foundational code. Using Firebase Studio, I was able to rapidly set up the backend services—database, hosting, and authentication—without getting bogged down in server management. Instead of spending days on repetitive tasks, I was able to stand up a basic version of the app in hours.

Architect the system: I used conversational AI to brainstorm and refine my application's architecture. I fed it my high-level goals and constraints (like using GitHub's API and a web-based editor), and it helped me map out a logical, scalable structure for the backend and frontend.

Integrate complex APIs: The GitHub API is powerful but can be tricky. My AI assistant helped me navigate the documentation and generate the precise code snippets needed to handle authentication and repo fetching, saving me from hours of debugging.

Create the "AI brain": This is where it gets really meta. I used AI to build the core logic for the app's AI feature—the part that reports errors and suggests improvements. I was able to prototype different approaches and fine-tune the prompts to get the most accurate and helpful responses.

Without this AI-driven development process and the rapid prototyping environment of Firebase Studio, this project would have stalled. The AI wasn't just a helper; it was a co-pilot, an architect, and a problem-solver all in one.

Under the Hood: How the AI in the Editor Works

So, how does the AI within my new online IDE actually work? It's not just a fancy linter. It’s an interactive, context-aware assistant.

When a user opens a file, the AI backend performs a real-time analysis of the codebase. Instead of just flagging syntax errors, it can:

Report logical bugs: It identifies potential issues like an unhandled edge case or an inefficient loop.

Suggest security improvements: It flags common vulnerabilities like SQL injection risks or unvalidated inputs.

Propose architectural improvements: It looks at the bigger picture, suggesting ways to refactor code for better performance or readability.

Explain the "why": For every issue it finds, it provides a clear, concise explanation of why it’s a problem and offers a direct, one-click solution that a user can apply immediately.

This is the future of development. It’s not about replacing developers; it's about giving them a superpower. It allows us to focus on the truly complex, creative problems while the AI handles the routine, tedious aspects of finding and fixing errors.

What's Next? And a Challenge to You

This project proves that with modern tools, what was once considered impossible is now within reach for any developer. The lines between "coder" and "creator" are blurring. You no longer need to be a full-stack expert to build a full-stack application. You just need to know how to leverage the right tools.

This project is a testament to the power of AI in development. It’s a complete game-changer. I challenge you to think about that project you've been putting off because it seemed too big. Re-evaluate it. With AI as your co-pilot, the only limit is your imagination.

Want to try it out? Leave a comment with your thoughts, and I'll share a link to the app's public beta. I'd love to hear what impossible project AI has helped you tackle.

Checkout the app here - https://repopilot-code.vercel.app/

I created a web app with Firebase studio

Aman Jaswal — Thu, 07 Aug 2025 16:51:10 +0000

Aman Jaswal

May 30 '25

Can you build, deploy and run a web app in 5 mins ?

#ai #firebasestudio #vibecoding

Comments

3 min read

Developing a database from scratch

Aman Jaswal — Thu, 07 Aug 2025 16:44:30 +0000

Developing a database from scratch, rather than using an existing one like MySQL or PostgreSQL, involves creating the core software that manages data storage, retrieval, and integrity. This is a highly technical undertaking that requires a deep understanding of computer science principles.

Core Components of a Database System

To build a database from the ground up, you would need to develop several key components:

Storage Engine: This is the lowest level of the database, responsible for how data is physically stored on disk or in memory. You would need to decide on a file format and implement methods for reading and writing data efficiently. This involves managing pages, blocks, and indexes to ensure fast access to records. For a simple database, you could start with a B-Tree or B+ Tree data structure to create an index for fast lookups.
Query Processor: This component handles incoming queries, typically in a language like SQL. It's composed of two main parts:
- Parser: Takes a query string and checks its syntax. It then converts the query into an internal representation, such as an abstract syntax tree (AST).
- Optimizer: This is a complex part of the system. The optimizer's job is to figure out the most efficient way to execute the query. It looks at the query and the available indexes and data statistics to generate a query plan that minimizes disk I/O and processing time.
Transaction Manager: This is crucial for ensuring data integrity and consistency. A transaction manager must implement the four properties of ACID (Atomicity, Consistency, Isolation, Durability).
- Atomicity means all operations in a transaction either succeed or fail as a single unit.
- Consistency ensures a transaction brings the database from one valid state to another.
- Isolation guarantees that concurrent transactions don't interfere with each other. A common way to achieve this is through locking mechanisms (e.g., read locks, write locks).
- Durability ensures that once a transaction is committed, its changes are permanent, even in the event of a system crash. This is often achieved by writing changes to a transaction log or write-ahead log (WAL) before they are applied to the main data files.
Concurrency Control Manager: This component allows multiple users to access and modify data at the same time without causing conflicts. This is often implemented using locking protocols (pessimistic concurrency) or a technique like Multi-Version Concurrency Control (MVCC) (optimistic concurrency), which creates a separate version of the data for each transaction.

Technologies and Languages

The development of a database system is typically done using low-level, high-performance languages.

C and C++: These are the most common languages for this purpose due to their ability to provide direct memory management and high performance. They are essential for building the storage engine and other core components where every CPU cycle and memory access counts.
Rust: Increasingly popular in recent years for systems programming, Rust offers memory safety guarantees without a garbage collector, which is a major advantage for building robust and reliable database systems.

The process of learning this type of development involves mastering these languages and studying the algorithms and data structures used in database systems. A good starting point would be to read books on database systems and implementation, which cover the theoretical concepts behind these components in detail.

Read my other posts

Can you build, deploy and run a web app in 5 mins ?

Aman Jaswal — Fri, 30 May 2025 15:38:41 +0000

Alright, let's cut to the chase. We've all built countless apps. We know our stacks. So when I decided to spin up InvoiceFlow – a Next.js, React, ShadCN, and Tailwind project – the question wasn't if I could build it, but how to do it with maximum efficiency and maybe, just maybe, a little bit of new-age sorcery. I threw Firebase Studio's AI Prototyper into the ring. Skeptical? You bet. Surprised? Absolutely.

The Mission: InvoiceFlow & A Challenge to the AI

The brief: a clean invoice generator. The stack: familiar territory. The twist: could an AI partner truly accelerate a seasoned dev's workflow, or would it just be a glorified snippet generator? I decided to treat the AI less like a student and more like a specialist tool.

My initial prompts were direct, no hand-holding:

Prompt Example 1 (Initial Setup):

The AI churned out the boilerplate, the component shells, and the initial schema definitions with unnerving speed. This wasn't just snippets; it was foundational code, ready for refinement.

Gremlin Hunting & Feature Sprints, AI-Style

No project is without its gremlins, but we also had feature sprints that the AI accelerated. First, the classic Next.js hydration errors:

Prompt Example 2 (Hydration Debug):

AI's Diagnosis & Fix:

The Prototyper immediately pinpointed the dynamic data generation. The solution was textbook, but implemented instantly. Efficient.

Then came the

tag hydration error -the kind that makes you suspect browser extensions. Prompt:

Next, wiring up the 'Share via Email' button quickly.

Prompt Example 3 (Feature Implementation):

The AI produced the function, complete with URL encoding for subject and body, null checks, and toast integration, ready in moments. Less fumbling with encodeURIComponent and conditional logic for me.

Finally, the PDF print job spewing blank pages was the next target.

Prompt Example 4 (PDF Print Fix):

The AI didn't just tweak a line; it architected a robust @media print stylesheet. Less trial-and-error for me, more targeted problem-solving.

The Real Value for Pros: Beyond Code Generation

So, what's the takeaway for those of us who've been around the block? It's not about learning fundamentals. It's about leverage and flow state.

Boilerplate Obliteration: Zod schemas, form handling, UI component integration – tasks that are necessary but often tedious. The AI turned these into near-instant operations.

Rapid Prototyping & Iteration: Ideas translated to functional UI at a pace that kept the creative momentum high. No more getting bogged down in the minutiae of initial setup.

Intelligent Debugging Partner: Sometimes, a "second pair of eyes," even artificial ones, can spot patterns or suggest fixes that cut down debugging time significantly. It’s like having a pair programmer who has memorized every common issue and solution.

Focus on Architecture: With the routine tasks streamlined, more of my brainpower went into the hard problems: application state strategy, user experience flow, and future scalability.

This isn't about the AI "writing the app for you." It's about it being an incredibly potent force multiplier. It handles the knowns, so you can conquer the unknowns.

The verdict? AI coding partners aren't just for beginners. For experienced developers, they represent a paradigm shift – a way to reclaim time, reduce friction, and amplify expertise. Ignore them at your peril. The future of development isn't just writing code; it's orchestrating it. And this AI? It’s a hell of a first chair.

How to Markdown ? Style your text in web

Aman Jaswal — Thu, 01 Oct 2020 10:51:14 +0000

𝗪𝗵𝗮𝘁 𝗶𝘀 𝗠𝗮𝗿𝗸𝗱𝗼𝘄𝗻?

𝗠𝗮𝗿𝗸𝗱𝗼𝘄𝗻 is an easy-to-use syntax for styling and formatting text on the web. You can use it to format readme files.

𝗠𝗮𝗿𝗸𝗱𝗼𝘄𝗻 is also used to format text in GitHub: Gist, comments, and files with extension .𝚖𝚍 𝚘𝚛 .𝚖𝚊𝚛𝚔𝚍𝚘𝚠𝚗. And not to forget we use Markdown for text formatting in DEV.to as well.

Here's a short list of 𝗠𝗮𝗿𝗸𝗱𝗼𝘄𝗻 formatting:

📌𝗛𝗲𝗮𝗱𝗲𝗿𝘀

# This is an <h1> tag
## This is an <h2> tag
###### This is an <h6> tag

This is an <h1> tag

This is an <h2> tag

This is an <h6> tag

📌𝗘𝗺𝗽𝗵𝗮𝘀𝗶𝘀

*This text will be italic*
_This will also be italic_

**This text will be bold**
__This will also be bold__

_You **can** combine them_

This text will be italic
This will also be italic

This text will be bold
This will also be bold

You can combine them

📌𝗟𝗶𝘀𝘁𝘀

🔸Unordered               
* Item 1
* Item 2
* Item 2a
* Item 2b

🔸Ordered
1. Item 1
1. Item 2
1. Item 3
1. Item 3a
1. Item 3b

🔸Unordered

Item 1
Item 2
Item 2a
Item 2b

🔸Ordered

Item 1
Item 2
Item 3
Item 3a
Item 3b

📌𝗜𝗺𝗮𝗴𝗲𝘀

![Markdown](https://upload.wikimedia.org/wikipedia/commons/thumb/4/48/Markdown-mark.svg/1024px-Markdown-mark.svg.png)

Format: ![Alt Text](url)

📌𝗟𝗶𝗻𝗸𝘀

[Progressive Programmer](https://www.linkedin.com/in/aman-singh-jaswal/)

Format: ![Text](link)

Progressive Programmer

📌𝗕𝗹𝗼𝗰𝗸𝗾𝘂𝗼𝘁𝗲𝘀

> We're living the future so
> the present is our past.

We're living the future so
the present is our past.

📌𝗜𝗻𝗹𝗶𝗻𝗲 𝗰𝗼𝗱𝗲

Use backticks to add
`<Inline code>` element

Use backticks to add
<Inline code> element

📌 𝗕𝗹𝗼𝗰𝗸 𝗰𝗼𝗱𝗲

Use three backticks at starting and end

𝐈 𝐡𝐨𝐩𝐞 𝐭𝐡𝐢𝐬 𝐰𝐚𝐬 𝐡𝐞𝐥𝐩𝐟𝐮𝐥 !! 🚀🚀🚀

𝐃𝐨 𝐧𝐨𝐭 𝐟𝐨𝐫𝐠𝐞𝐭 𝐭𝐨 𝐝𝐫𝐨𝐩 𝐦𝐨𝐫𝐞 𝐦𝐚𝐫𝐤𝐝𝐨𝐰𝐧 𝐬𝐭𝐲𝐥𝐢𝐧𝐠 𝐢𝐧 𝐭𝐡𝐞 𝐜𝐨𝐦𝐦𝐞𝐧𝐭𝐬 𝐛𝐞𝐥𝐨𝐰 👇🏾

Aman JaswalFollow

Learning the art of programming! After a gap of 3 years I am back here to share what I have learned so far! Happy to share

Git Commands for beginners!

Aman Jaswal — Tue, 22 Sep 2020 22:22:46 +0000

Configure Git

# list all the configured values
git config --list 

# Set username & email for git globally
git config --global user.name "Progressive Programmer"
git config --global user.email "progressive@gmail.com"

# Set committer name & email for git
git config --global committer.name "Programmer"
git config --global committer.email "programmer@gmail.com"

Create a new Repository

# Create a new folder and initialize git repo
git init name  

# Clone a remote repo in your local system
git clone url_of_repo

Add files/folders to Staging Area

# Adds mentioned file/folder to the staging area
git add hello.py 

# Adds all the files and folders in the current directory 
git add . 

# Opens the file and let you choose 
the portion to be added for next commit  
git add -p hello.py

Commit Changes

# Commit a snapshot of staged changes
git commit  

# Commit a snapshot of changes in the working directory. 
git commit -a

# Shortcut for commit with a commit message 
git commit -m "commit message"

Git Branching

# Create a new branch
git branch crazy_experiment

# List all branches 
git branch
# List both remote and local branches   
git branch -a
# List only branches that match the pattern mentioned 
git branch --list  'pattern here'

Switch | Delete | Rename Branch


# Move to different branches
git checkout branch_name
git switch  branch_name

# Shortcut to create a new branch and switch to the branch  
git switch -c  new_branch_name
git checkout -b  new_branch_name 

# Delete the given branch 
git branch -d  trash
# Force delete the given branch 
git branch -D  trash

# Rename the current branch 
git branch -m  new_name

Merge Branch


# Merge given branch name with the working branch
git merge  branch_name
# Continue merger after conflict resolution
git merge  --continue

Check Status

# Shows the working tree status
git status  

# Shows status of working tree in a short format 
git status --short

# Shows status of branch in a short format 
git status --branch

Remote Repository


# Lists remote repo name and url(fetch/push) 
git remote -v

# Add a remote repository with local repository 
git remote add origin url_remote_repo

# Remove the remote repo with given name
git remote remove repo_name

# Rename the remote repo with given name
git remote rename old_name new_name

# Updates remote repo with local repo 
git push

I hope this helps !!🚀🚀

Which is your favorite git command??

Don't forget to drop your thoughts and feedback in the comment section. Also, feel free to suggest any addition to this list..

Learn Git visually !! BEST WAY TO LEARN GIT

Aman Jaswal — Tue, 22 Sep 2020 07:53:10 +0000

Git is a powerful version control system which is essential for programmers. But at the same time Git has a very steep learning curve as it requires a deep understanding and exposure to the process of programming.

Git offers a number of tools to handle multiple programming contributions, changes, sorting, comparison while keeping track of all.

One the best way that I found to understand all of that is through visualization of git.

👉🏾 https://learngitbranching.js.org/ 🚀🚀🚀🚀

Learngitbranching offers that visualisation and is brilliant to start from zero and gradually understand the different stances of branching.

🏀🏀

6 Best online IDEs

Aman Jaswal — Sat, 19 Sep 2020 18:26:21 +0000

Online IDEs these days are powerful enough to provide frameworks and libraries.

While we are away from the desktop or system, we can always use online IDEs to stay productive.

6 Best online IDEs

Repl.it repl.it
Gitpod gitpod.io
StackBlitz stackblitz.com
CodePen codepen.io
CodeSandbox codesandbox.io
Codeshare codeshare.io

Online IDEs are easy for beginners as they have ready-to-code environment. You are not required to go through the trouble of debugging the setup process of, let's say, react. You are ready to start programming just by choosing the environment!!!

Another good reason to use an online IDE is that they are ready-for-collaboration. Code sharing, Pair coding becomes easy and without any setup or plugin.

We may also connect our online repositories- github to the online IDEs and all our repos will be instantly available for viewing or editing with the required environment.
Isn't that cool!!

These are some of the benefits that I observed since I started to learn programming. I am sure there are more that can be added to the list along with their downsides as well.

Help me add on to the list of online IDEs, their benefits and downsides.

Drop your comments below 👇🏾