teleren/devto huggingface dataset:
Talk: An Open-Source App for Talking with ChatGPT
Tags: chatgpt, opensource, speaking, github
Published: 2023-09-30 05:15:43

Hello, developers!

I am thrilled to announce the release of this open-source project, **Talk**. It's a single-page application designed to facilitate conversation with AI using **voice**, offering a user experience akin to a native app.

You can check out the [Demo](https://talk.proxoar.com/) here - no signup, no login, just start conversing. For an optimal experience, I recommend using Chrome.

For those interested in deploying their own version, I recommend exploring the user-friendly tutorial and source code available on GitHub: [https://github.com/proxoar/talk](https://github.com/proxoar/talk)



![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fkht8fx979dzl8gc0agf.png)


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lq2pjl6fwpx7i2i0o9i7.jpg)


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/272516mqznx0rnxuakfw.jpg)


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/is0qys97qkllh000bgo1.jpg)
Data Science for Beginners: 2023 - 2024 Complete Road Map
Published: 2023-09-30 05:15:26

##**Learn the Fundamentals**
A good place to start your data science journey would be to learn math and statistics which are very important to the field of data science. Learning a Programming language such as Python or R is very essential as these are the industry standard for data science.

##**Data Manipulation and Analysis**
Once you've gotten a grasp of the fundamentals, your next target should be learning about data manipulation and analysis using libraries like Pandas, NumPy, and SQL. Understanding data visualisation using libraries like Matplotlib and Seaborn are using very essential skills for a data scientist and data analyst to pocess.

##**Machine Learning Fundamentals**
Once you've understood how to manipulate data, being able to use that data to train machine learning models is one of the skills a data scientist needs. Learn basic machine learning algorithms (e.g., regression, classification, classification, clustering) and techniques.
While understanding model evaluation and validation.

##**Advanced Machine Learning**
Once you are comfortable working with the fundamental algorithms and techniques of machine learning. A Deeper dive into machine learning algorithms and techniques (e.g., ensemble methods, deep learning, natural language processing, computer vision) is the best next step. While exploring model tuning and optimization.

##**Big Data and Cloud Computing** 
Data scientist generally work with large data sets, so familiarizing yourself with big data technologies (e.g., Hadoop, Spark) and cloud platforms (e.g., AWS, Azure, GCP).

##**Working on Projects**
With all this knowledge obtained, it only makes sense to test your mastery by delving into real world projects to gain experience. Showcasing these projects on public repositories on GitHub or a personal portfolio.

##**Domain Specialization**
After working on several personal projects, you get the sense of what aspects of data science you do best or love best you can decide to specialize in one these domains. 

##**Stay Updated**
Keep up with the latest trends, advancements and technologies in data science as the field of data science is a relatively new field and technology advancement is fast paced.
List down possible risks and explanation that could be included in the test plan for web application.
Published: 2023-09-30 05:09:31

Task 3 – Question 3

A test plan is a systematic approach to testing a system such as a machine or software. The plan typically contains a detailed understanding of what the eventual workflow will be.
In software testing, a test plan gives detailed testing information regarding an upcoming testing effort, including

- Scope of testing.
- Schedule.
- Test Deliverables.
- Release Criteria.
- Risks and Contingencies.

Below are the possible risks that could be included in the test plan.

•	Lack of personnel resources when testing is to begin.

•	Lack of availability of required hardware, software, data or tools.

•	Late delivery of the software, hardware or tools.

•	Delays in training on the application and/or tools.

•	Changes to the original requirements or designs.

•	Complexities involved in testing the applications

•	Test environment not available for testing.
Demystifying TypeScript Generics with Simple Examples
Tags: typescript, javascript, ts, webdev
Published: 2023-09-30 04:31:57

TypeScript Generics can seem daunting at first, but they are a powerful tool for creating flexible and type-safe code. In this article, we'll explore Generics through easy-to-understand examples, breaking down the concepts step by step.

### What Are Generics?

Generics in TypeScript allow you to write code that can work with different data types while still maintaining type safety. Think of them as placeholders for types that you specify when you use them.

### Generic Functions

Let's start with the basics by looking at generic functions:

```typescript
function echo<T>(arg: T): T {
    return arg;
}
```

Here, `echo` is a generic function. The `<T>` part inside the parentheses declares that `T` is a type parameter. It's like saying, "I'll tell you the type later."

Now, when you call `echo` and provide an argument, TypeScriptfigures out the type based on what you pass:

```typescript
let result = echo("Hello, TypeScript"); // result is of type 'string'
```

In this case, `result` is automatically recognized as a string because we passed a string as an argument.

### Generic Classes

Generics aren't limited to functions; you can also use them with classes. Consider a simple example of a generic class `Box`:

```typescript
class Box<T> {
    private value: T;

    constructor(value: T) {
        this.value = value;
    }

    getValue(): T {
        return this.value;
    }
}
```

In this class, `T` is a type parameter that represents the type of the `value` property. When you create a `Box` instance, you specify the type it will hold:

```typescript
let numberBox = new Box<number>(42); // numberBox can only hold numbers
let stringBox = new Box<string>("Hello, TypeScript"); // stringBox can only hold strings
```

TypeScript ensures that you can't mix types within a `Box`. Trying to do so would result in a compile-time error.

### Real-World Applications

Now that you've grasped the basics, let's see where Generics can be valuable:

1.**Array Functions**: Many array methods like `map`, `filter`, and `reduce` use Generics under the hood to work with different element types.

2. **Promises**: Promises can return various types of values, and Generics help define the expected return type when using `Promise<T>`.

3. **React Components**: Creating reusable components that can work with different data types as props.

4. **API Requests**: When fetching data from an API, Generics can specify the expected shape of the response data.

### Conclusion

Generics might appear complex at first glance, but they're a valuable tool for writing versatile and type-safe code. By using them, you can create functions, classes, and data structures that adapt to different types while catching type errors early in the development process. As you become more comfortable with Generics, you'll find them indispensable in building robust and maintainable TypeScript applications.
Working with parallel branches
Published: 2023-09-30 03:59:09

For this week in [Topics in Open Source Development](https://github.com/Seneca-CDOT/topics-in-open-source-2023) at Seneca College, I was tasked with creating multiples changes across two new feature branches in my [til-to-html](https://github.com/paulkim26/til-to-html) application for [lab 3](https://github.com/Seneca-CDOT/topics-in-open-source-2023/wiki/lab-3).

Repository: https://github.com/paulkim26/til-to-html

Issues:
- [Issue 15](https://github.com/paulkim26/til-to-html/issues/15) ([merge commit](https://github.com/paulkim26/til-to-html/commit/70046c1fd809e0ba1f3e171cebbf204b6ab7b461))
- [Issue 16](https://github.com/paulkim26/til-to-html/issues/16) ([merge commit](https://github.com/paulkim26/til-to-html/commit/6e3ab4d375d8b9fa031e71e6a6781ff90d287442))

## New Features

I added two new features for this week; properly exiting with error codes and adding support for Markdown horizontal rules in my Markdown parser.

The process of implementing the new exit handling logic was simple enough. I added calls to  `process.exit()` within my main entry point. I already caught errors and handled them gracefully, so I added an exit with a return code of `1` to my `catch` clause.

```ts
import parseArguments from "~/parseArguments";

const args = Bun.argv.slice(2);
try {
  await parseArguments(args);
  process.exit(0);
} catch (e: any) {
  console.error(e.message);
  process.exit(1);
}
```

Adding the horizontal rule Markdown parsing was more involved and required some refactoring. After I added a new [parseHorizontalRule.ts](https://github.com/paulkim26/til-to-html/blob/main/src/parse-markdown/parseHorizontalRule.ts) module, I had to modify my [parse-markdown](https://github.com/paulkim26/til-to-html/blob/main/src/parse-markdown/index.ts) module to differentiate between block element (headers, horizontal rules) and inline element (bold, italics, links) Markdown. If the Markdown element was an inline element, I would encapsulate the resulting line of html with a `<p>` tag. If it a block level element, I would not do so, otherwise I would inadvertently wrap i.e. `<h1>` tags with `<p>` tags, adding a lot of redundant whitespace.

## Merging

I made sure to work with each of these features only within their respective branches. Once I was done, I checked out the `main` branch and performed a `git merge` for each branch one after another. The first merge was painless. In the second merge, I had a merge conflict within the readme where I was writing to the same line. I resolved the merge conflict with the VS code merge conflict resolution editor by manually ordering the new lines one after the other. I'm thankful I didn't have further conflicts to fix. I knew from previous experience not to mix and match code changes across branches within the same files/lines.

Thanks for reading!
oneAPI moves to Unified Acceleration Foundation (UXL)
Tags: sycl, opensource, ai, hpc
Published: 2023-09-30 03:36:38

As accelerators have become more prevalent in the industry there has been a bifurcation in the industry which typically resolves itself. Initially there has been many efforts by a myriad of vendors in the GPU accelerator space with various degrees of openness.

For a long period of time, incubation of the oneAPI ecosystem started at Intel through both DPC++ SYCL compiler, and the publishing of open specifications of oneAPI and their open source implementations. While the messaging around the specs were that they were open to all contributors – it could be hard to feel comfortable especially for competitors to enter spaces where the perception is that it isn’t a true neutral space. 

With oneAPI spec’s now under the aegis of the Linux Foundation the spec and the open source implementations will be well managed under established norms. There is now a true center of gravity to work together as equal partners on the oneAPI spec and their open source implementations.
 
We can now focus on driving a true industry driven standard on heterogeneous computing under the UXL Foundation and have some serious collaboration to finally use all your hardware. This will herald a sustainable ecosystem that we can all be proud of.

There are still challenges going forward. How our toolchains work together under UXL Foundation is going to be important going forward. We can address these concerns by vigorously participating in the UXL Foundation. Creating an open ecosystem is always challenging as many many partners need to agree and align on goals and processes. Listening to each other and the community is going to be key going forward.

With all that being said - I hope that you will take the time to look at what has been established so far. We have a humble beginning but with your help and participation we can take it to the next level. For further reading, please see https://uxlfoundation.org/. Looking forward to seeing you all there.

Cover image: Photo by <a href="https://unsplash.com/@sunburned_surveyor?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Scott Blake</a> on <a href="https://unsplash.com/photos/DodJfxuH46I?utm_source=unsplash&utm_medium=referral&utm_content=creditCopyText">Unsplash</a>
React Button Hover Animation
Tags: html, css, javascript
Published: 2023-09-30 03:31:41


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uum0dgsusxeh60uqm442.png)
Visit for source code : [https://freecodez.com/post/is3n0s3](https://freecodez.com/post/is3n0s3)
I'm trying to running the react-native application
Tags: reactnative, mobile, android, softwaredevelopment
Published: 2023-09-30 03:18:49

                Welcome to Metro v0.76.8
              Fast - Scalable - Integrated

r - reload the app
d - open developer menu
i - run on iOS
a - run on Android

info Opening the app on Android...
warn No apps connected. Sending "reload" to all React Native apps failed. Make sure your app is running in the simulator or on a phone connected via USB.
info Reloading app...


versions
    

```
`"react": "^18.2.0",
    "react-native": "0.72",`
```

Showing app is running but it's not running anywhere
Python: Posting on X with Tweepy
Tags: tutorial, python
Published: 2023-09-30 03:15:20

There are a few libraries for Python that can be used to get access to the X API. I used [twitter](https://pypi.org/project/twitter/) previously for a project that is documented [here](dev.to/mattdark/automate-your-posting-process-on-dev-with-python-bash-and-gitlab-ci-5fm6) and can be found in this GitLab [repository](https://gitlab.com/mattdark/dev-blog-posting/). 

Due to the recent changes in the X API, and the library not being updated in about a year, I was getting the following error:

```bash
details: {'errors': [{'message': 'You currently have access to a subset of Twitter API v2 endpoints and limited v1.1 endpoints (e.g. media post, oauth) only. If you need access to this endpoint, you may need a different access level. You can learn more here: https://developer.twitter.com/en/portal/product', 'code': 453}]}
```

The solution was to used [Tweepy](https://github.com/tweepy/tweepy), a Python library well documented and prepared to be used with the version 2 of the X API.

Through this blog post, you will learn how to use Tweepy for posting updates on X.

## Create an app in the X Developer Portal
If you don't have a developer account, you must create one, in order to use the X API. You have to [apply](https://developer.twitter.com/en/apply-for-access) for getting access.

Once your developer account is approved, go to [developer.twitter.com/en/portal/dashboard](https://developer.twitter.com/en/portal/dashboard) and [create a new app](https://developer.twitter.com/en/portal/apps/new), then generate the API Key and Secret, and an Access Token and Secret for your app.

## Installation
To install the latest version of Tweepy you can use pip:

```bash
pip install tweepy
```

## Posting from Python
Let's create a script to post updates on X.

First, import the Tweepy library into your project:

```python
import tweepy
```

Then, add the following variables:

```python
consumer_key = '' #API Key
consumer_secret = '' #API Key Secret
access_token = ''
access_token_secret = ''
```

Authenticate with your credentials to be able to use the X API:

```python
client = tweepy.Client(
    consumer_key=consumer_key, consumer_secret=consumer_secret,
    access_token=access_token, access_token_secret=access_token_secret
)
```

And finally, create a new post on X:

```python
text = 'Hello, World!'
client.create_tweet(text=text)
```

This is a basic example of Tweepy. Check the [documentation](https://docs.tweepy.org/en/stable/) for additional information and [examples](https://docs.tweepy.org/en/stable/examples.html).

---

[![Support me on Buy Me A Coffee](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/nzx9uenqvwqv1vp8ub5d.png)](https://buymeacoffee.com/letstalkoss)
Parallel Branches
Published: 2023-09-30 02:10:10

## New Features
This week's task in my open source course was to add a couple of new features to my text to HTML [converter](https://github.com/Amir-Helali/Txt2StaticHtml). The goal of this task was to gain experience with creating parallel branches when working on new features, to learn about fast-forward and three-way-recursive merges and to handle merge conflicts.

## Language Support Feature
This [feature](https://github.com/Amir-Helali/Txt2StaticHtml/issues/6) was added to allow the user to specify the language they would like to use when converting their files to HTML. To use this feature the user can simply run the program with -l or --lang \<language-code> \<file-path> and the converted HTML file will include the language in the root \<html> element. I created a new [branch](https://github.com/Amir-Helali/Txt2StaticHtml/tree/languageSupport) to work on implementing the changes needed for this functionality.

## Horizontal Rule Feature
This [feature](https://github.com/Amir-Helali/Txt2StaticHtml/issues/5) was added to support horizontal rule conversion from markdown to HTML. Again, I created a new [branch](https://github.com/Amir-Helali/Txt2StaticHtml/tree/horizontalRule) to work on coding this new functionality parallel to the previous feature. When converting a markdown file to HTML, if the markdown file has horizontal rule indicators like: *** or --- or ___, they will be converted to an hr tag in the HTML.

## Merging Process
After I finished coding both functionalities and committing the changes to their respective branches I merged my horizontal rule branch to my main, which was a fast-forward merge and after that I merged my language support branch. During the second merge there were some conflicts, but I simply fixed them and made sure that everything was working before completing the merge. The commit for language support can be found [here](https://github.com/Amir-Helali/Txt2StaticHtml/commit/4537b13b4ed3198551a2cf1dafeb2a0c8d613747) and the commit for horizontal rule support can be found [here](https://github.com/Amir-Helali/Txt2StaticHtml/commit/82db6e6e6828851499e8994edc0ac541714a7a9e)

## The Problems
I didn't come across any issues completing this task. The only thing that worried me a bit were the merge conflicts, but they were easily fixed and I tested everything to make sure that they didn't break anything.

## What I learned
It was cool to learn that a commit code can be used in the comments when closing an issue and the issue will be linked to the commit which closed it.
A new Node.js v20 (Current) is now available! 💚
Tags: webdev, javascript, programming, node
Published: 2023-09-30 03:08:32

"Exciting news for developers! Node.js has just unleashed its latest and greatest version, Node.js version 20(current)🚀 Dive into this comprehensive guide to discover the game-changing features, performance enhancements, and practical insights that come with this milestone release. Stay at the forefront of modern web development by upgrading to Node.js 20.0 today! 💡
- More performance improvements
- More test runner features
- More bugfixes!
See the full changelog for v20.8.0 in the blog:[](https://nodejs.org/en/blog/release/v20.8.0
Working with parallel branches and merges
Tags: opensource, github, regex, python
Published: 2023-09-30 02:55:22

Today I took on adding some more markdown conversion functionality to my [ez-txt2html]( https://github.com/bryce-seefieldt/ez-txt2html) converter.  I worked on adding functionality that recognizes markdown’s horizontal rule tag `---` and converts it to  html `</ hr>`. As well I added inline code tag conversion that recognizes and converts single tick inline code tags to `<code>…</code>` html tags, along with triple tick fenced code blocks which can support a multiline code block in the resulting html doc.  The biggest challenge in incorporating this functionality was to be able to open the fenced code block on a given line of text and then close it later in the document.  This is because my method of recognizing and replacing markdown tags works line by line and required a Boolean flag to indicate whether the current occurrence of the triple tick should be replaced by an open code or close code block tag (`<code>` or `</code>`). As well it was important to convert fenced code blocks (triple tick) prior to addressing inline single tick tags, otherwise fenced code blocks would be confused as multiple single tick tags.
As an exercise in working on parallel branches, I worked on horizontal rule and inline code functionality on separate branches and waited until both issues were complete to merge my commits on each respective branch.  It was a fairly straightforward process, with just a few conflicts generated in my attempt to merge the second branch.  This was easily resolved using the conflict review tools provided in both GitHub and codespaces.  By accepting both incoming changes I was able to successfully merge the branches and create 2 pull requests ([PR17]( https://github.com/bryce-seefieldt/ez-txt2html/pull/17) and [PR18]( https://github.com/bryce-seefieldt/ez-txt2html/pull/18)).  You can see the detailed steps outlining the commits and the merge process in commits [cdcf8b5](https://github.com/bryce-seefieldt/ez-txt2html/commit/cdcf8b5f3f6c7d413fb072e7233a66249cc31843) and [a599961](https://github.com/bryce-seefieldt/ez-txt2html/commit/a599961e9f00f7b07092a988fc21c31024d802ea).  While the merge process wasn’t overly complicated, it does take some time to make sure you are assessing the conflicts in detail and not approving unwanted code or eliminating desired code in the process.  I found the conflict review tools on GitHub itself to be the most streamlined and user-friendly method to approving conflicts to succesfully merge branches.  As well I found this [GitHub Docs – Resolving a merge conflict using the command line] (https://docs.github.com/en/pull-requests/collaborating-with-pull-requests/addressing-merge-conflicts/resolving-a-merge-conflict-using-the-command-line) and [Rohan Dawkhar’s Medium article - Resolving Merge Conflicts (GitHub): A Step-by-Step Guide]( https://rohan-dawkhar.medium.com/resolving-merge-conflicts-github-a-step-by-step-guide-%EF%B8%8F-f9ae4ac6f075) to be very helpful walkthroughs in order to understand merging.