DEV Community: Riley Sage

How I Turned a Simple Habit Tracker Into a $15K/Month App

Riley Sage — Mon, 06 Oct 2025 16:35:20 +0000

A couple of years ago, I quit my job with no plan. No product. No cofounder. Just twelve months of savings and a vague idea that I wanted to build something.

It was terrifying. Everyone told me I was crazy and honestly, they were probably right. Six months later, I had a handful of failed apps, maybe ten downloads total, and the slow realization that I might have made a huge mistake.

But then something shifted. A small idea, really and it changed everything.

The Burnout Before the Breakthrough

I’d been a software developer at a mid sized company in Germany for three years. It was fine stable, decent pay, friendly coworkers but every day felt the same.
I wanted to create my own things, not just build what someone else planned. So I decided to quit and give myself one year to figure it out. My goal was simple: make something that could pay the bills.

Spoiler: I didn’t.
At least, not right away. The first six months were failure after failure. I’d build small apps, release them, and then watch them sink into the void of the App Store without a trace.

Still, I kept going.
And then I built something I actually needed myself — a simple, privacy-friendly habit tracker.

Building Habit Kit

The idea behind Habit Kit was basic: help people track habits in a clean, visual way no logins, no data collection, no dark patterns. Just a minimalist grid where you could see your progress.

I used Flutter, which let me build for iOS and Android at the same time. I posted some screenshots online while I was still developing it, mostly to keep myself accountable. To my surprise, people liked it a lot. That tiny bit of positive feedback kept me going.

I released the app two months later. And this time… it didn’t flop.

The Growth That Didn’t Come From Ads

I didn’t have money to run ads or hire marketers. So instead, I decided to build in public.
Every week, I shared updates about the app what I was working on, what broke, what I learned. I was honest, even about the stuff that failed. People connected with that.

That openness brought opportunities I never expected: podcast invites, collaborations, shoutouts from other indie devs. It built trust and that trust turned into users.

The other key was App Store Optimization (ASO). I learned how the App Store’s search worked how to pick the right keywords, structure titles, and get more reviews.

One little trick that worked: I asked users to rate the app right after they checked off their first habit. They’d just had a small win, so most of them left five stars. That alone boosted the app’s visibility massively.

Today, Habit Kit has over 300,000 downloads and makes about $15,000/month.

Doing It Alone

I still run everything by myself. My total expenses are around $300/month, mostly for tools like:

RevenueCat for handling subscriptions
AppFigures for analytics
Cursor as my AI-powered code editor
And of course, Habit Kit itself which I still use every day

I’m not a startup. I’m just one person with a laptop and Wi-Fi. And somehow, that’s enough.

What I Learned

Looking back, I think the real turning point wasn’t the app — it was the mindset.
I stopped chasing “big ideas” and started building things that solved my problems.

And honestly, quitting my job (twice!) was necessary. After coding all day at my corporate job, I didn’t have the mental energy to build on the side. I needed that space to focus completely, even if it meant failing for a while.

If you’re thinking of doing something similar, here’s my advice:
Save some money. Set a time limit. And give yourself permission to try — really try — without expecting instant success.

Worst case? You go back to work.
Best case? You build the thing that changes your life.

Final Thoughts

Habit Kit started as a personal experiment and turned into a full-time business.
It wasn’t luck. It wasn’t a viral post. It was small, steady progress — the same principle the app itself is built on.

Now, thousands of people use it to build their own good habits.
That’s the coolest part — the thing I made to fix my own problems is now helping others with theirs.

If you’re stuck on the fence about chasing your idea, remember this:
You don’t need permission. You just need to start.

Difference between Interface and Type in TypeScript

Riley Sage — Tue, 30 Jan 2024 16:15:26 +0000

In TypeScript, both interfaces and types are used to define custom data structures, but there are some differences in their capabilities and use cases. Here are the key distinctions between interfaces and types:

Interfaces:

Declaration Merging:
- Interfaces in TypeScript support declaration merging. This means that if you declare two interfaces with the same name, they will be merged into a single interface.

   interface Person {
     name: string;
   }

   interface Person {
     age: number;
   }

   // Merged into a single interface
   // Resulting interface: { name: string; age: number; }

Extending Interfaces:
- You can extend other interfaces using the extends keyword.

   interface Animal {
     name: string;
   }

   interface Dog extends Animal {
     breed: string;
   }

Implementing Classes:
- Interfaces can be used to define the shape of a class and ensure that a class adheres to a particular structure.

   interface Printable {
     print(): void;
   }

   class Document implements Printable {
     print() {
       console.log("Printing document...");
     }
   }

Types:

Union and Intersection:
- Types in TypeScript can represent union and intersection types, allowing you to create complex types by combining multiple types.

   type UnionType = string | number;
   type IntersectionType = { prop1: string } & { prop2: number };

Support for Primitives:
- Types can represent primitive types directly.

   type Age = number;

Mapped Types:
- Types can be used to create mapped types, allowing you to transform the properties of an existing type.

   type Optional<T> = {
     [P in keyof T]?: T[P];
   };

Tuple Types:
- Types can be used to define tuple types.

   type Point = [number, number];

When to Choose:

Use Interfaces When:
- You want to represent the shape of an object or define contracts for classes.
- You need declaration merging or want to extend other interfaces.
Use Types When:
- You need to create union or intersection types.
- You want to create mapped types or define complex types.
- You are working with primitive types or tuple types.

In many cases, interfaces and types can be used interchangeably, and the choice between them often comes down to personal preference or specific use-case requirements.

Thank you for reading. I encourage you to follow me on Twitter where I regularly share content about JavaScript and Typescript, as well as contribute to open-source projects and learning Typescript. I am currently seeking a remote job.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

Langfuse: A Beacon of Open Innovation for LLM Developers

Riley Sage — Sun, 05 Nov 2023 15:20:31 +0000

Langfuse

In the rapidly evolving landscape of large language models (LLMs), Langfuse has emerged as a beacon of open innovation, empowering developers with powerful observability and analytics tools to optimize their LLM applications. Its open-source nature, coupled with an active and supportive community, has propelled it to become a trusted choice among developers worldwide. With the backing of the renowned Y Combinator accelerator, Langfuse has garnered impressive traction, boasting over 1.2k stars on GitHub and 1.1k upvotes on Product Hunt, further solidifying its position as a leading LLM observability and analytics platform.

A Community of Humble Experts

As a software developer and Langfuse contributor, I've firsthand witnessed the incredible depth of knowledge and willingness to help that permeates the Langfuse community. The Discord channel, in particular, serves as a vibrant hub of discussion, where experienced contributors patiently guide newcomers through technical challenges and share their expertise.

Integration Made Easy: Overcoming Non-Coding Hurdles

Integrating Langfuse analytics can sometimes pose challenges, especially for those with limited coding experience. However, the Langfuse community is committed to making the integration process as seamless as possible. I'm personally here to assist anyone facing integration hurdles, offering personalized guidance and support. Whether it's navigating technical complexities or adapting to the nuances of LLM integration, I'm just a message away on Telegram (https://t.me/didk9675) or you can find other communication method on GitHub (https://github.com/DIWAKARKASHYAP).

Langfuse: An Open-Source Powerhouse with Y Combinator Backing

Langfuse stands out as a shining example of open-source software at its finest. Its open-source nature, coupled with its comprehensive documentation and self-hosted or cloud-based deployment options, makes it an accessible and versatile tool for anyone seeking to delve into the world of LLM analytics. With the backing of Y Combinator, one of the world's most prestigious startup accelerators, Langfuse has gained access to valuable resources and mentorship, further accelerating its development and growth.

Key Features That Empower Developers:

Open Source: Langfuse embraces the open-source philosophy, fostering collaboration and innovation under the MIT license.
Self-Hosting Flexibility: Langfuse offers the flexibility of self-hosting, locally or on cloud platforms, providing developers with control over data management.
Model Agnostic: Langfuse seamlessly integrates with various LLM models, ensuring broad compatibility and observability.
Comprehensive SDKs: Langfuse provides fully asynchronous SDKs for JavaScript/TypeScript (Node, Edge) and Python, simplifying integration and data collection.
Rapid Langchain Integration: Langfuse integrates seamlessly with Langchain, enabling full integration in just five minutes.
Public API for Custom Integrations: Langfuse's public API empowers developers to build custom integrations and downstream use cases.
Drop-in OpenAI SDK Replacement: Langfuse provides a drop-in replacement for the OpenAI SDK, requiring only a change in import statements.
JS/TS Web SDK for Client-Side Scoring: Langfuse's Web SDK enables developers to capture scores directly from the client-side, providing valuable insights into user interactions.
Incremental Adoption for Gradual Integration: Langfuse allows for incremental adoption, starting with a single LLM call and gradually expanding to full tracing of complex chains/agents.
GET API for Downstream Use Cases: Langfuse's GET API empowers developers to build downstream use cases, leveraging detailed trace data for advanced analysis.

Benefits of Using Langfuse:

Enhanced Observability: Langfuse provides deep insights into LLM performance, enabling developers to identify and address issues promptly.
Optimized Costs: Langfuse helps developers monitor and optimize LLM usage, reducing costs and improving resource utilization.
Improved Quality: Langfuse enables developers to measure and improve the quality of LLM outputs, ensuring consistent and reliable performance.
Actionable Analytics: Langfuse delivers actionable analytics, empowering developers to make data-driven decisions and enhance their applications.

Conclusion:

Langfuse stands as a testament to the power of open-source collaboration and the dedication of passionate contributors. Its comprehensive features, coupled with its supportive community, make it an invaluable tool for anyone seeking to harness the potential of LLMs while maintaining control over their data and applications. If you're an open-source enthusiast, a software developer, or simply curious about the world of LLMs, I strongly encourage you to explore Langfuse and join its vibrant community.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

Top 5 AI Chatbot Platforms: Your Guide to Building Chatbots with Ease

Riley Sage — Fri, 03 Nov 2023 14:15:24 +0000

Introduction

Hi, I'm Diwakar Kashyap, a software engineer. I'm the perfect person to give you advice on creating AI chatbots. If you're not a coder or you're feeling overwhelmed by the process, I can even create a fully customized AI chatbot for you.

Just message me on any social media app https://github.com/DIWAKARKASHYAP or comment section below.

Why AI chatbots are essential in 2023

AI chatbots are essential for businesses and clients in 2023. They allow users to easily interact with websites and get the information they need quickly and easily.

For example, a customer can use an AI chatbot to ask questions about a product or service, book an appointment, or even get help with troubleshooting a problem.

https://amzn.to/3rAUCu1

The 5 best AI chatbot platforms

Now, let's explore five of the top AI chatbot platforms available in 2023, each with its unique set of features and benefits:

1. Flowise

Flowise is an excellent choice for those who want to create chatbots trained on their own data. Even if you lack coding experience, this platform is user-friendly and intuitive. With Flowise, you can design and deploy AI chatbots tailored to your specific needs.

2. Botpress

If you're aiming to develop ChatGPT-like bots with advanced capabilities, Botpress is a powerful platform to consider. It offers a wide range of features, making it suitable for businesses seeking versatile and sophisticated chatbot solutions.

3. Vectara AI

Vectara AI is an ideal choice for businesses in need of chatbots that seamlessly integrate with other AI tools and platforms. It provides scalability and extensibility, making it a robust option for organizations looking to implement advanced AI chatbots within their existing systems.

4. Wit AI

For businesses looking to create chatbots that can understand and respond to natural language, Wit AI is a prime choice. It excels in handling complex and nuanced conversations, making it a valuable tool for organizations with intricate customer interactions.

5. Botonic

Botonic is the platform of choice for creating chatbots with a graphical user interface. It's perfect for businesses that want to offer an engaging and interactive user experience. With Botonic, you can build chatbots that captivate and delight your users.

How to choose the right AI chatbot platform

When choosing an AI chatbot platform, you should consider the following factors:

Budget: Some AI chatbot platforms are more expensive than others. Be sure to choose a platform that fits your budget.
Technical expertise: Some AI chatbot platforms require more technical expertise than others. If you're not a coder, you'll want to choose a platform that's easy to use.
Features: Consider the specific features that you need in an AI chatbot platform. For example, do you need a platform that can integrate with other AI tools and platforms? Do you need a platform that can create chatbots with a graphical user interface?

Conclusion

AI chatbots are an essential tool for businesses in 2023. They can help you improve customer service, increase sales, and automate tasks.

If you're looking for a way to create an AI chatbot, I recommend checking out the five platforms that I mentioned in this blog post. There's a platform for everyone, regardless of your budget, technical expertise, or specific needs.

I hope this feedback is helpful!

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

What is Private field in JS (JavaScript)

Riley Sage — Thu, 19 Oct 2023 04:20:55 +0000

In JavaScript, the term "private field" typically refers to a concept related to encapsulation and access control in object-oriented programming. JavaScript traditionally lacked native support for private members in classes, but with the introduction of ECMAScript 2015 (ES6) and subsequent versions, private fields and methods became possible.

in easy language, In JavaScript, a "private field" is like having a secret inside a special box. Imagine you have a box, and you want to keep something hidden inside it so that others can't mess with it. That hidden thing is a private field.

Private fields are used to encapsulate data within a class, making it accessible only from within that class. They are declared using the # symbol as a prefix to the field name. Here's a simple example:

class MyClass {
  #privateField;

  constructor(value) {
    this.#privateField = value;
  }

  getPrivateField() {
    return this.#privateField;
  }

  setPrivateField(newValue) {
    this.#privateField = newValue;
  }
}

const myObject = new MyClass(42);

console.log(myObject.getPrivateField()); // Output: 42
myObject.setPrivateField(99);
console.log(myObject.getPrivateField()); // Output: 99
console.log(myObject.#privateField); // Error: Private field '#privateField' must be declared in an enclosing class

In this example, #privateField is a private field of the MyClass class. It can only be accessed or modified from within the class methods. If you try to access it directly from outside the class, an error will occur.

Private fields help in achieving encapsulation, which is an important principle in object-oriented programming. Encapsulation involves bundling the data (fields) and methods (functions) that operate on the data within a single unit, i.e., a class. This helps in hiding the internal details of the class and exposing only the necessary functionalities.

It's worth noting that private fields are a feature of modern JavaScript, and older browsers or environments may not support them. Always consider the target environment when using language features introduced in newer specifications.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

How to participate and win Hacktoberfest

Riley Sage — Mon, 02 Oct 2023 04:47:08 +0000

Hacktoberfest is an annual celebration dedicated to fostering contributions to open-source software. Organized by DigitalOcean in collaboration with partners like Intel, AppWrite, and DeepSource, this month-long event occurs each October. Its primary goal is to inspire developers worldwide to engage with open-source projects and make meaningful contributions.

https://amzn.to/3rAUCu1

To participate in Hacktoberfest, you must first create a GitHub account and then register for the event on the official Hacktoberfest website. Once registered, you can commence contributing to any open-source project actively participating in the event. Discovering these projects is made easy by searching for the "hacktoberfest" topic on GitHub.

To successfully "win" Hacktoberfest, you need to have at least four pull requests accepted by project maintainers within the timeframe of October 1 to October 31. Achieving this milestone qualifies you for a unique digital reward.

Consider these tips for a rewarding Hacktoberfest experience:

Start Early: Initiate your contributions early in the month to allow ample time for finding projects aligned with your interests and having your pull requests accepted.
Choose Beginner-Friendly Projects: If you're new to open-source contributions, opt for projects with beginner-friendly issues. These issues are typically well-documented and provide clear steps for resolution.
Practice Patience: Reviewing pull requests can take time for project maintainers. Be patient and persistent in your contributions.
Seek Help When Needed: If you encounter challenges, don't hesitate to seek assistance from other contributors or project maintainers. The open-source community values collaboration and mutual support.

For crafting effective pull requests, consider these guidelines:

Address Real Issues: Ensure your pull requests address genuine problems or enhancements rather than submitting changes solely for the sake of participating in Hacktoberfest.
Clear and Concise Commit Messages: Craft commit messages that succinctly describe the purpose of your changes and why they are necessary.
Test Your Changes: Prior to submitting a pull request, verify that your alterations don't introduce new issues and function as intended.
Respect Project Maintainers: Be courteous and understanding when your pull requests undergo review. Collaborate constructively with maintainers for improvements.

Tips to Win Hacktoberfest (although it's more about participation and contribution rather than "winning"):

Quality Over Quantity:

Focus on meaningful contributions rather than just trying to meet the minimum requirements. Quality contributions are more valuable to the open-source community.

Engage with the Community:

Participate in discussions, ask questions, and collaborate with other contributors. Being an active and positive member of the community enhances your overall experience.

Follow Project Guidelines:

Make sure to read and adhere to the guidelines of the projects you're contributing to. This includes coding standards, documentation requirements, and any specific contribution guidelines.

Help Others:

If you see issues raised by others that you can help with, feel free to jump in and contribute. Collaboration and teamwork are essential in open source.

Hacktoberfest presents a fantastic opportunity to delve into the realm of open-source software, offering a chance to learn, collaborate, and contribute to projects you are passionate about. If you're a developer, seize this opportunity to participate and make a positive impact on the open-source community.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

"as" in TypeScript | "as" keyword in TypeScript

Riley Sage — Sat, 23 Sep 2023 13:16:11 +0000

In TypeScript, the as keyword is used for type assertion, which is a mechanism that allows you to explicitly specify the type of a value when the TypeScript compiler cannot determine the type with complete certainty. Type assertion tells the TypeScript compiler to treat a value as if it were of a specific type. This can be particularly useful when you, as a developer, have more knowledge about the types in your code than TypeScript's static analysis can provide.

Here's a more in-depth explanation of how as works in TypeScript:

Type Safety vs. Developer Confidence:
- TypeScript's main goal is to provide type safety by statically analyzing your code and catching type-related errors at compile-time.
- However, there are situations where the type system cannot guarantee the correct type, such as when dealing with external data sources, dynamic values, or complex type inference.
Type Assertion Syntax:
- To perform type assertion, you use the as keyword followed by the target type in parentheses.
- It's like telling TypeScript, "Trust me, I know the type of this value."
```
 let value: any = "Hello, TypeScript!";
 let length: number = (value as string).length;
```
Narrowing Types:
- Type assertion can help narrow the type of a value within a specific code block, allowing you to access properties or methods associated with that type.
```
let user: unknown = getUserData();
if (typeof user === "object") {
  let username: string = (user as { name: string }).name;
}
```
Use Cases for Type Assertion:
- Working with third-party libraries that have incomplete or incorrect type definitions.
- Parsing JSON data from an API response, where TypeScript cannot infer the exact shape of the data.
- When migrating existing JavaScript code to TypeScript and needing to preserve flexibility.
Risks of Type Assertion:
- Type assertion should be used judiciously because it overrides TypeScript's type checking. If you assert the wrong type, it can lead to runtime errors.
- Incorrect type assertions can compromise the type safety that TypeScript provides.
Alternative Approaches:
- Whenever possible, use type annotations and interfaces to describe the shape of data and functions, allowing TypeScript to provide more comprehensive type checking without the need for type assertion.
- Use type guards like typeof, instanceof, or custom functions to narrow types without type assertions.

In summary, the as keyword in TypeScript is a tool that provides developers with a way to assert the type of a value when TypeScript's type inference is insufficient or when dealing with dynamic or external data. However, it should be used with caution to avoid compromising the benefits of TypeScript's static type checking.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

"type" keyword in Typescript | What is Type Alias ?

Riley Sage — Sat, 23 Sep 2023 06:17:08 +0000

Type aliases in TypeScript allow you to create custom names for complex types, making your code more readable and maintainable. They are particularly useful when dealing with complex data structures, union types, and other scenarios where you want to give a clear name to a specific type. Type aliases are created using the type keyword.

Here's a deep explanation of type aliases with examples:

1. Basic Type Alias:
You can create a type alias for a simple data type like this:

type Age = number;
let userAge: Age = 30;

In this example, we've created a type alias called Age, which is essentially a synonym for the number type. It makes the code more self-explanatory when you use Age instead of number.

2. Custom Object Type Alias:
Type aliases are especially handy when defining custom object types:

type Person = {
  name: string;
  age: number;
};

let person: Person = {
  name: "Alice",
  age: 25,
};

Here, we've created a Person type alias that represents the structure of a person object. This makes it clear what properties are expected for a Person without having to repeat the type definition.

3. Union Type Alias:
Type aliases are often used for union types, which allow a variable to have multiple possible types:

type Result = number | string;

let value1: Result = 42;
let value2: Result = "Success";

In this case, Result can be either a number or a string. It's a convenient way to define a custom union type.

4. Function Type Alias:
You can also create aliases for function types:

type Calculator = (a: number, b: number) => number;

const add: Calculator = (x, y) => x + y;

Here, Calculator is a type alias for a function that takes two numbers and returns a number. It provides clarity when dealing with functions in your code.

5. Combining Type Aliases:
You can combine type aliases to create more complex types:

type Point = {
  x: number;
  y: number;
};

type Color = {
  color: string;
};

type ColoredPoint = Point & Color;

let coloredPoint: ColoredPoint = {
  x: 10,
  y: 20,
  color: "red",
};

In this example, we create Point and Color type aliases and then combine them using an intersection (&) to create a ColoredPoint type. This illustrates how type aliases can be used to build up more intricate types.

Type aliases help improve code readability and maintainability by giving meaningful names to complex types and reducing redundancy in your code. They also make your code more self-documenting and make it easier for other developers (or your future self) to understand the intent of your code.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

Which Jobs in Tech Will AI🤖 Replace⚠️? The Trending Debate

Riley Sage — Sun, 03 Sep 2023 11:54:30 +0000

Artificial Intelligence (AI) is no longer a concept confined to sci-fi movies. With exponential growth in technology, AI is becoming an intrinsic part of our day-to-day lives. From virtual assistants like Siri and Alexa to more complex implementations in healthcare and finance, the footprint of AI is everywhere. But with its advancement comes the inevitable question: Which jobs in the tech industry are most at risk from AI?

1. Routine Data Tasks

The days of manual data entry might be numbered. AI algorithms are exceptionally good at sorting, categorizing, and analyzing vast datasets at speeds incomparable to human performance. As a result, tasks that involve routine data handling are prime candidates for AI automation.

2. Software Testing

While a human touch is indispensable for nuanced understanding and intuition-based testing, AI can run multiple test scenarios simultaneously, checking software for bugs or glitches more quickly than a team of human testers.

3. Customer Support

The first point of contact for many online services is already an AI chatbot. As these virtual assistants become more sophisticated, we can expect them to handle more complex queries, reducing the need for human intermediaries.

4. Network Management

Predictive maintenance driven by AI can detect anomalies in networks, leading to reduced outages and improved user experiences. Manual monitoring might become less of a norm.

5. Cybersecurity

In an age of increasing cyber threats, AI-driven systems can offer real-time threat detection and response, often faster and more accurately than human-led teams.

6. Website Design and Development

Automated platforms can now generate basic websites. Future AI-driven tools might offer personalized, adaptive designs based on user behavior and preferences.

7. Technical Support

For anyone who's spent hours troubleshooting a technical problem, the appeal of an AI system that can instantly diagnose and rectify issues is undeniable.

8. Content Moderation

Given the sheer volume of user-generated content on platforms like Facebook or YouTube, AI-driven content moderation can ensure safer, more respectful online spaces.

9. Image and Video Editing

Tasks like color correction, object recognition, and even some aspects of video editing can be enhanced or automated with AI.

10. Translation and Localization

Basic translations are already performed by tools like Google Translate. As these tools become more sophisticated, we might find human translators focusing more on nuanced or specialized content.

The Human Touch Still Matters

While AI's capabilities are expanding, it's crucial to remember the irreplaceable value of human intuition, creativity, and understanding. Jobs that require deep empathy, subjective judgment, or high-level strategic thinking will always benefit from a human touch.

Moreover, as AI reshapes the employment landscape, new roles and opportunities will emerge. Just as the rise of the internet created jobs that were previously inconceivable, so will the rise of AI. Tech professionals can prepare by continually upskilling, adapting, and learning to harness AI as a tool rather than viewing it as competition.

The debate around AI and job replacement is trending, and rightfully so. By understanding and anticipating these shifts, we can ensure that the future of tech is both innovative and inclusive.

Thank you for reading. I encourage you to follow me on Twitter where I regularly share content about JavaScript and React, as well as contribute to open-source projects and learning golang. I am currently seeking a remote job or internship.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

How to Build AI 🤖 like ChatGPT 😱

Riley Sage — Sat, 02 Sep 2023 11:14:55 +0000

Building an AI model similar to ChatGPT is a complex task, and delving deep into it requires exploring various facets of machine learning, deep learning, natural language processing, and infrastructure setup. Here's an in-depth breakdown:

1. Foundational Knowledge:

Deep Learning Foundations: Study deep neural networks, backpropagation, activation functions, and optimization techniques.
Transformers and Attention Mechanisms: GPT (like ChatGPT) is built using transformers. Understand how self-attention works and how it facilitates capturing contextual information.

2. Data Collection & Management:

Sources: Use datasets like Common Crawl, BooksCorpus, Wikipedia, etc.
Storage: Due to the size of datasets, cloud storage or distributed file systems like Hadoop HDFS might be necessary.
Data Quality: Ensure data diversity and representation. Clean data by removing duplicates, inappropriate content, etc.

3. Preprocessing:

Tokenization: Convert text into tokens using techniques like byte-pair encoding (BPE) or SentencePiece.
Chunking: Divide data into manageable chunks or sequences to feed into the model.

4. Infrastructure:

Hardware: Use high-performance GPUs or TPUs. Multi-GPU or distributed training may be necessary for larger models.
Software: Utilize deep learning frameworks like TensorFlow or PyTorch.

5. Model Design:

Architecture: Adopt the transformer architecture. Choose the model size (number of layers, hidden units, attention heads).
Regularization: Implement techniques like dropout or layer normalization to prevent overfitting.

6. Training:

Initialization: Start weights with small random values.
Learning Rate & Schedulers: Adaptive learning rates (e.g., Adam optimizer) and learning rate warm-up can stabilize training.
Loss Function: Use cross-entropy loss for language modeling.
Gradient Clipping: Prevent exploding gradients.
Monitoring: Track metrics like perplexity to gauge model performance.

7. Evaluation:

Metrics: Use metrics such as BLEU, ROUGE, METEOR for specific tasks or perplexity for general language modeling.
Validation Set: Keep a separate dataset for evaluation during training to prevent overfitting.

8. Fine-tuning:

Task-specific Data: Use datasets related to specific tasks like translation, summarization, etc.
Lower Learning Rate: Often, a reduced learning rate is used to prevent drastic updates that could harm pre-learned features.

9. Deployment:

Model Serving: Tools like TensorFlow Serving or TorchServe can be used to deploy models.
Scaling: Consider solutions like Kubernetes for scalability.
APIs: Create RESTful or GraphQL APIs to provide access to the model.

10. Monitoring & Maintenance:

Feedback Loop: Collect user feedback for continuous improvement.
Retraining: Periodically fine-tune or retrain the model with fresh data.

11. Ethical & Safety Measures:

Bias Mitigation: Evaluate the model for biases and implement techniques to reduce them.
Output Filters: Put measures in place to prevent the model from producing harmful or inappropriate content.
Transparency: Provide users with information on how the model works and its potential limitations.

12. Resources & Communities:

Pre-trained Models: Utilize models like GPT-2, which are publicly available, to bootstrap your efforts.
Libraries & Tools: HuggingFace’s Transformers library is invaluable for working with models like GPT.
Engage with the Community: Stay updated with the latest advancements by participating in forums, reading papers, and attending conferences.

This deep dive provides a roadmap, but each step is a significant undertaking. Experience, collaboration, and iterative experimentation are crucial to successfully building a model of this caliber.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

Concurrency in Go (Golang)

Riley Sage — Wed, 30 Aug 2023 16:11:22 +0000

Go (or Golang) makes it easy to do many things at once using goroutines, channels, and the select statement. Let's break it down step by step.

1. Goroutines:

In Go, a goroutine is like a mini-task that the computer can handle. It's like having multiple helpers that can work together. Starting a goroutine is simple:

go functionName()

Just put the word "go" before the function you want to do at the same time. Imagine it's like telling your computer, "Hey, do this task while I do other things!"

For example:

func sayHello() {
    fmt.Println("Hello from a helper!")
}

func main() {
    go sayHello()
    fmt.Println("Hello from the main task!")
}

In this code, the helper says "Hello" while the main task also says "Hello." Sometimes the helper might finish first, and sometimes the main task might finish first. It's like a little race!

2. Channels:

Channels are like special tubes that help the helpers (goroutines) talk to each other. They can send and receive messages. It's like passing notes between friends.

Here's how you make a channel:

ch := make(chan int)

This creates a channel that can carry numbers. You can send and get data from it:

go func() {
    ch <- 42  // Sending 42 through the channel
}()

value := <-ch  // Getting a value from the channel
fmt.Println(value)

3. Select Statement:

The select statement is like a helper that watches multiple channels at once. It's like someone watching multiple phones for calls. When a call comes on any phone, they answer it.

For example:

select {
case msg1 := <-ch1:
    fmt.Println("Got", msg1)
case msg2 := <-ch2:
    fmt.Println("Got", msg2)
case ch3 <- 3:
    fmt.Println("Sent 3 to ch3")
default:
    fmt.Println("No messages")
}

This select helper listens to different channels. If a message comes on any channel, it does something. If many channels have messages, it picks one to answer. It's like a multitasking helper!

Quick Tips:

No Sharing Memory: Goroutines talk with channels, so we don't need to worry about sharing information directly. It's like talking through notes instead of fighting over toys.
Buffered Channels: Channels can hold messages before they're read. It's like a mailbox that can store letters.
Range and Close: Channels can be closed when no more messages will come. You can also use a range to read all messages like collecting all the candies.
Sync Package: There's a special tool called the sync package. It helps when things get more complicated, like when many helpers need to work together.

In Conclusion:

Go's way of doing many things at once is smart and easy. It's like having helpers, talking through channels, and using select to manage them. It's much simpler than old ways of doing many things together.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/

Interfaces and Embedding in Golang (Go)

Riley Sage — Tue, 29 Aug 2023 17:27:52 +0000

1. Interfaces in Go:

1.1. What are Interfaces?

In Go, an interface is a type that specifies a set of method signatures. When a concrete type provides definitions for all the methods in an interface, it is said to implement the interface.

1.2. Defining Interfaces:

You define an interface using the type keyword followed by the interface name and the interface keyword:

type Writer interface {
    Write([]byte) (int, error)
}

1.3. Significance in Go's Type System:

Interfaces in Go allow you to:

Define behavior that types should fulfill.
Enable polymorphic behavior. You can write functions and methods that accept interface types, and then pass values of any concrete type that satisfies the interface.
Provide a way to define contracts. If a type implements an interface, it guarantees certain methods with defined signatures are present in the type.

1.4. Interface Values:

Interface values can hold any value that implements the specified methods. An interface value has two components: a value and a concrete type. When we call a method on an interface value, the method of its underlying type is executed.

var w Writer
w = os.Stdout
w.Write([]byte("Hello, Go!\n"))

In the above example, os.Stdout implements the Writer interface, so we can assign it to the w variable. When we call w.Write, it calls os.Stdout.Write.

2. Embedding in Go:

2.1. What is Embedding?

Embedding allows one struct type to include another struct, inheriting the fields and methods of the embedded type. It is Go's mechanism to achieve composition over traditional inheritance.

2.2. How to Embed:

To embed a type, you declare a field in the struct without a field name, just the type:

type Address struct {
    Street, City, State string
}

type Person struct {
    Name string
    Address
}

p := Person{
    Name:    "Alice",
    Address: Address{"123 Main St", "Anytown", "CA"},
}
fmt.Println(p.Street)  // Output: 123 Main St

In the above code, Person embeds Address. This means that a Person not only has a Name but also has Street, City, and State due to the embedded Address.

2.3. Inheritance-like Behavior:

Embedding provides a way to "inherit" methods. If the embedded type has methods, the embedding type will have those methods too, provided it doesn't define its own methods with the same name.

func (a Address) FullAddress() string {
    return a.Street + ", " + a.City + ", " + a.State
}

// Even though Person doesn't define FullAddress, it gains the method through embedding Address.
address := p.FullAddress()

However, Go doesn't support classical inheritance where you can extend and override base class methods. Instead, Go promotes composition over inheritance, making systems easier to understand and maintain.

To summarize:

Interfaces in Go allow types to adhere to contracts and enable polymorphism.
Embedding allows structs to inherit fields and methods from other structs, giving a mechanism for composition over classical inheritance.

Twitter: https://twitter.com/Diwakar_766

GitHub: https://github.com/DIWAKARKASHYAP

Portfolio: https://diwakar-portfolio.vercel.app/