teleren/devto huggingface dataset:
Chat GPT-4 Already Used In the Wild (Stripe, Duolingo, Khan Academy, etc...)
Tags: chatgpt, programming, webdev, productivity
Published: 2023-03-16 02:41:20

## Stripe

Stripe, a leading online payment processing platform, is leveraging ChatGPT-4 to enhance its customer support experience. [Read more](https://openai.com/customer-stories/stripe)

- Automating customer support responses
- Assisting human agents with accurate information
- Reducing response times for customer queries

## Duolingo

Duolingo, a popular language-learning platform, is using ChatGPT-4 to improve its language learning tools and user experience. [Read more](https://openai.com/customer-stories/duolingo)

- Enhancing language learning exercises
- Generating contextual language examples
- Offering personalized feedback to users

## Khan Academy

Khan Academy, an educational organization providing free online courses, is utilizing ChatGPT-4 to supplement its learning materials. [Read more](https://openai.com/customer-stories/khan-academy)

- Providing instant feedback on student work
- Generating additional practice questions
- Assisting teachers in creating personalized learning experiences

## Be My Eyes

Be My Eyes, an app that connects blind and low-vision individuals with sighted volunteers, is implementing ChatGPT-4 to offer real-time assistance. [Read more](https://openai.com/customer-stories/be-my-eyes)

- Translating text in images for visually impaired users
- Providing instant support through AI-based responses
- Reducing dependency on human volunteers for text recognition tasks

## Morgan Stanley

Morgan Stanley, a multinational investment bank and financial services company, is employing ChatGPT-4 for various financial applications. [Read more](https://openai.com/customer-stories/morgan-stanley)

- Analyzing financial documents
- Generating market insights and summaries
- Enhancing customer support in finance-related queries

## Government of Iceland

The Government of Iceland, in collaboration with Almannarómur and Miðeind, is using ChatGPT-4 to preserve the Icelandic language. [Read more](https://openai.com/customer-stories/government-of-iceland)

- Training GPT-4 on Icelandic grammar and cultural knowledge
- Developing voice assistant apps (Embla) for fluent Icelandic conversations
- Creating Icelandic-speaking chatbots for company websites

## AI Technology 

Each of these companies is using ChatGPT-4 in unique ways to improve their products, services, and user experience, demonstrating the versatility and potential of AI technology across various industries available as of today.

---

[Clean Code Studio](https://cleancode.studio)
10 differences you must know when choosing between Monolithic Vs Microservices Architecture
Tags: devops, monolithic, microservices, architecture
Published: 2023-03-16 02:31:00

Choosing the right architecture is crucial for any software development project. 

In software architecture, there are two popular approaches: monolithic and microservices. Monolithic architecture involves building an entire application as a single, cohesive unit, while microservices architecture involves breaking down an application into a collection of small, independently deployable services that communicate with each other through APIs.


Here are 10 differences you must know when choosing between Monolithic Vs Microservices Architecture:

## Difference 1

Monolithic architecture has a simple development workflow. Vs Microservices architecture has a complicated development workflow.

## Difference 2

Monolithic architecture has a single deployment process. Vs Microservices architecture has a flexible deployment of each service.

## Difference 3

Monolithic architecture is not flexible in adding new tech stack. Vs Microservices architecture is flexible in adding a new tech stack.

## Difference 4

Monolithic architecture has an easier testing process. Vs Microservices architecture has a complex testing process.


## Difference 5

Monolithic architecture has low scalability. Vs Microservices architecture has high scalability.

## Difference 6

In Monolithic architecture, minor changes are harder to implement. Vs In Microservices architecture, minor changes are easier to implement.

## Difference 7

Monolithic architecture has complicated onboarding. Vs Microservices architecture has agile and simpler onboarding.

## Difference 8

In Monolithic architecture, security is easier. Vs In Microservices architecture, security requires extra attention.


## Difference 9

Monolithic architecture is less reliable. Vs Microservices architecture is more reliable.


## Difference 10

In Monolithic architecture, there are future issues with speed. Microservices architecture has high sustainability.


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

Thanks for reading this.

If you have an idea and want to build your product around it, schedule a call with [me](https://calendly.com/pragyanatvade).

If you want to learn more in DevOps and Backend space, [follow me](https://dev.to/pragyanatvade).

If you want to connect, reach out to me on [Twitter](https://twitter.com/pragyanatvade) and [LinkedIn](https://www.linkedin.com/in/pragyanatvade/).
Realtime GitHub Readme Tweets
Published: 2023-03-16 02:05:22

Hey now you can integrate your tweets into github readme in realtime.
I have created a api which will fetch your tweets and give you a response in picture format.
A tweet looks like this:

![TWEET README LOOK](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/60ml9jld2k72ux0g3dht.png)

## Let's See how to integrate it in your readme.

### Step 1: visit [tweeco.pushkaryadav.in](https://tweeco.pushkaryadav.in/)

### Step 2: Enter your twitter username

here you have 2 choices. You can either enter your twitter username or you can enter a specific tweet url.

- Tweet username will always return a latest tweet in svg rendered form
- Tweet url will return a specific tweet in svg rendered form

### Step 3: Copy the markdown code and paste it in your readme file

![TWEECO WEBSITE](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6zqfgcw3qc3dn5wqnr05.png)

### Step 4: Costumization

You can costumize tweet with url parameters.
Here are some:

| Property Code   | Work                    |
| --------------- | ----------------------- |
| `?text=fff`     | text color              |
| `?border=000`   | border color            |
| `?width=700`    | width of image rendered |
| `?bg=333`       | background color        |
| `?title=F5D76E` | title color             |
| `?icon=F5D76E`  | twitter icon color      |

Modify the url with the above parameters and you will get a costumized tweet.

```md
[![](https://tweeco.pushkaryadav.in/api/handle/pushkaryadavin?text=fff&border=000&width=700&bg=333&title=F5D76E&icon=F5D76E)](https://tweeco.pushkaryadav.in)
```

![COSTUMIZED IMAGE](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/54ebd12h8r7n20j4bzvr.png)

- Do not use `#` in color code. Use `F5D76E` instead of `#F5D76E`
- For colors you can refer to [COLPIC](https://colpic.pushkaryadav.in/) or any color code website.

Step 5: Commit and Done.

- `PRO TIP 😎`: You can also use this api in your website. Just use the api url in your img tag.

## Need Help?

See our GitHub repo for more information and time to time upgrades.

- [GitHub Repository](https://github.com/pushkarydv/readme-tweets)
- [Tweeco website](https://tweeco.pushkaryadav.in/)
- [Twitter](https://twitter.com/pushkaryadavin)
30 Days of React JS: Tips and Tricks for Building Powerful Web Applications
Tags: react, webdev, javascript, frontend
Published: 2023-03-16 00:31:34

Over the past 8 months, I've been using React to build my own startup, and I'm excited to share my hard-won tips and tricks with you! In this series, I'll cover everything from the basics of React to more advanced concepts like state management, performance optimisation, and more.

Join me for a 30-day series on React JS that will provide you with valuable tips and tricks for building efficient and powerful web applications.

Whether you're a React newbie or a seasoned pro, you won't want to miss out on this series. Follow me on dev.to to get notified when the series starts, and be sure to check out my first post to get a taste of what's to come. The first post will be out on 20th March. 

Let's build great applications together!
The Loneliness of Trying to #EmbraceEquity in FAANG
Tags: wecoded, faang, aws, womenintech
Published: 2023-03-16 00:30:39

This year's theme for International Women's Day at my employer was #EmbraceEquity, with a slate of women-led talks and panels and some truly inspiring stories of women rising in the ranks of Amazon and AWS.

And I love that we're calling out the problem and (in theory) actively working on it, though we still have such a long way to go.

In practice, though, my day-to-day interactions look like this:

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

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

with the occasional

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

_(if you know, you know :sevh:)_

And then, inspired by a [tweet](https://twitter.com/LauraJHyatt/status/1633440151874465792) from a colleague, I did the math on my actual team, the people I interact with 90% of the time at work:

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

and all the hope and optimism IWD is supposed to inspire was brought crashing down by reality.

Don't get me wrong: I am incredibly lucky to work on a respectful, collaborative team of allies, and I have never felt discriminated by my immediate coworkers - they're awesome dudes! But there is something incredibly lonely about never (or hardly ever, if you count Slack) interacting with another member of your gender _in your role_. I'm jealous of my colleagues that don't have to feel that loneliness, and in my experience, no amount of women in tech meetups can fill that day-to-day gap.

## So what can we do about it?

I realize that the bigger the company, the more that equity is a marathon, not a sprint. A startup can hire two new engineers and suddenly the numbers are much closer to 50/50. At a FAANG, this process takes years and requires not just desire from the bottom, but buy-in from the top. And the top... well, let's just say it's even lonelier than I am:

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

_[Source](https://www.aboutamazon.com/news/workplace/our-workforce-data)_

This is compared to all corporate employees, which unfortunately are not broken down by job roles, as based on my experience over the past 1.5 years, the numbers for AWS specifically and all engineering roles are much worse:

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

The good news is that the numbers are getting better! But for someone working day to day in a very male-dominated environment, that change still feels far too slow. AWS has shown numerous times that when something matters, leadership can act much faster in a concentrated effort. I can only hope that this pledge to #EmbraceEquity results in more action than words.
How to convert Solidity JSON ABI to Human Readable ABI in Hardhat
Tags: tutorial, blockchain, solidity, hardhat
Published: 2023-03-16 00:27:42

When you develop dApps, one of the main requirements is to load the Application Binary Interface (ABI) into your frontend app. The methods and data structures of the contract are defined in the ABI, which is a JSON object. Although the JSON ABI may be used by programs to interact with the contract and is machine-readable, it can be challenging for people to understand. This post will cover the process of converting Solidity JSON ABI to a readable format using ethers.js

### Step 1: Get the Solidity JSON ABI
The first step is to obtain the Solidity JSON ABI from the smart contract. By utilizing the Solidity compiler to compile the contract or a program like Remix IDE, you can obtain the ABI. In this case, we are going to use hardhat.

### Step 2: Load the ABI
When hardhat compiling the smart contracts, the compiled file is stored in `artifacts/contracts/<your-contract-name>.sol/<your-contract-name>.json` path. If your contract is not compiled yet, simply run npx hardhat compilecommand to compile the contracts.

Let’s create a javascript file under the scripts folder called “convert-abi.js” and write the below code in your js file.


![create convert-abi.js file under scrips folder](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/6q4zi2ei8si1j9xb33bb.png)

```
touch convert-abi.js
```

{% gist https://gist.github.com/anjana-j/08fbaa0aeb7389142a14111eac38bf63 file=convert-abi.js %}

Ether.js is supporting three outputs mainly named “json”, “full” and “minimal”. Using the “full” format will ensure the result objects have named properties, which improves code readability. Although the “minimal” format will save some room, it is typically not worthwhile because named properties on results won’t be present. So, we will use “full” format type.

### Step 3: Convert the JSON ABI
Simply run the below command in your terminal.

```
npx hardhat run scripts/convert-abi.js
```

![Output displays after running convert-abi.js](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jvkuksxw4cusk7sx4nve.png)


Copy the output and use it in your project as you see fit.

### Conclusion
Converting Solidity JSON ABI to a human-readable format can be a useful tool for understanding the interface of a smart contract. This can be useful for smart contract writers as well as for anyone interested to gain a better understanding of how a contract works.

Happy Coding!
O que faz de uma linguagem Orientada a Objetos? Por Peter Wegner
Tags: braziliandevs, oop, webdev, programming
Published: 2023-03-16 00:27:24

Isso era um assunto controverso nos anos 80.

Em 87, Peter Wegner, publicou um artigo na OOPSLA que resolveu a questão (pelo menos entre aqueles que concordam com o Wegner) 
Para uma linguagem ser Orientada a Objetos ela precisa segundo Wegner 

ser baseada em objetos, ou seja, deve ser fácil programar objetos que encapsulam dados e operações;

ser baseadas em classes, ou seja, cada objeto pertence a (ou é fabricado a partir de) uma classe; e +
permitir herança, ou seja, deve ser fácil agrupar classes em hierarquias de subclasses e superclasses.

Outros estudiosos (chatos?) acrescentam outros itens à lista: (eu não concordo - Wegner)
enlace dinâmico, tardio (late binding)

A linguagem Self é uma grande exceção entre as linguagens claramente orientada a objetos: ela não possui classes. 

JS e Lua tem coletores de lixo e não são baseadas em classes. 

Para Wegner essas não são linguagem OOP.

Fontes: 
https://dl.acm.org/doi/abs/10.1145/38765.38823
ipcRenderer communicate with ipcMain by Typescript in Electron
Published: 2023-03-16 00:22:19

In Electron applications, you can use the `ipcRenderer` and `ipcMain` modules for inter-process communication. The official documentation provides a version in JavaScript. Below are the steps to implement it in TypeScript, along with the problems encountered during the process.

## Listen for messages in the main process

Use `ipcMain` in the main process to set up IPC listeners:

```
import { ipcMain } from 'electron';

ipcMain.on('setTitle', (event, title) => {
  const webContents = event.sender;
  const win = BrowserWindow.fromWebContents(webContents)
  win?.setTitle(title);
});

ipcMain.handle('ping', (event, value) => {
  return `${value} pong`;
});
```

## Expose ipcRenderer APIs through preload.ts

By default, the front-end does not directly access the Electron module or use ipcRenderer. Instead, it does so through preload.ts.

```
import { contextBridge, ipcRenderer } from "electron";

//expose global window.electronAPI for font-end by contextBridge 
contextBridge.exposeInMainWorld('electronAPI', {
  modifyTitle: (newTitle: string) => { ipcRenderer.send('setTitle', newTitle) },
  ping: async (data: string) => {
    const result = await ipcRenderer.invoke('ping', data);
    return result;
  }
});
```

## renderer.ts uses the interface in preload.ts

In the rendering process, use the functions by window.electronAPI.

```
window.electronAPI?.modifyTitle(newTitle);
const result = await window.electronAPI?.ping("ping");
```

## Above are examples of ipcMain - preload - renderer. Below are the steps to implement in Typescript:

final directory structure of the files:

```html
|-- src
	|-- main.ts
	|-- preload.ts
	|-- renderer.ts
|-- index.html
|-- package.json
|-- tsconfig.json
```

1, Typescript project initialization

```html
# install typescript
yarn global add typescript
# check tsc command
tsc -v 
# init
tsc --init

# generate the tsconfig.json，and modify two places
{
  "compilerOptions": {
    "rootDir": "./src",
    "outDir": "./dist",
  }
}
```

2, Import the front-end entry page and the preload.ts in main.ts.

```html
const mainWindow = new BrowserWindow({
  webPreferences: {
    preload: path.join(__dirname, "preload.js"),
  },
});
mainWindow.loadFile(path.join(__dirname, "../index.html"));
```

3, preload.ts serves as a bridge to expose ipcRenderer to the frontend.

```html
// declare the window.electronAPI, nor the font-end can't access electronAPI
declare global {
  interface Window {
    electronAPI: any;
  }
}

contextBridge.exposeInMainWorld('electronAPI', {});
```

4, Import renderer.ts in index.html. Pay attention to the path: dist

```html
<!-- attention the path -->
<script src="./dist/renderer.js"></script>
```

5, the start scripts in package.json, also need to pay attention to the path: dist

```html
scripts: {
	"start": "tsc && electron ./dist/main.js"
}
```

Full source code is available at [https://github.com/vuerust/electron-typescript-starter](https://github.com/vuerust/electron-typescript-starter)

If you find my article helpful, please feel free to give a tip. Your support will encourage me to keep creating!
What are Managed-inventory-service for a Game?
Tags: gamedev, virtualgoods, gameeconomy, gameitems
Published: 2023-03-16 00:13:55

A Managed Inventory Service in a game is a tool or service that helps game developers manage the in-game items and virtual economy of their game. It provides features such as player inventories, item stores, and virtual currencies that can be customized to suit the game's requirements. This service allows developers to create, edit, and manage game items without the need for server-side programming. Additionally, a Managed Inventory Service may include analytics and reporting tools to help developers track the performance of their virtual economy. By using a Managed Inventory Service, game developers can focus on creating engaging gameplay experiences without worrying about the complexity of managing their virtual economy.

This [article introduces](https://beamable.com/blog/introducing-beamables-managed-inventory-service) Beamable's Managed Inventory Service, which is a tool for game developers that helps them manage their in-game items and virtual economy. The service enables developers to create, edit, and manage their game items without the need for server-side programming. It also offers a range of features such as player inventories, item stores, and virtual currencies that can be customized to suit the game's requirements. The service also includes analytics and reporting tools to help developers track the performance of their virtual economy. By using Beamable's Managed Inventory Service, game developers can focus on creating engaging gameplay experiences without worrying about the complexity of managing their virtual economy.

Summary: 
Beamable's Managed Inventory Service is a tool for game developers to manage in-game items and virtual economies.
The service allows developers to create, edit, and manage game items without server-side programming.
It offers player inventories, item stores, and virtual currencies that can be customized to fit the game's needs.
The service includes analytics and reporting tools to help developers track virtual economy performance.
By using Beamable's Managed Inventory Service, developers can focus on creating engaging gameplay experiences without worrying about managing virtual economies.
JavaScript Data Types
Tags: javascript, beginners, flatiron, flatironschool
Published: 2023-03-15 23:06:30

Understanding the different types of data that can be used in JavaScript is essential for building reliable and efficient programs. In this blog post/quick lecture notes, we'll briefly explore the different types of JavaScript data types.

## Primitive
Primitives are data types that do not have named attributes. They do not have methods or properties either. 

The Seven Primitive Data Types are:

1. String  - representation of a sequence of characters enclosed in single (') or double (") quotes
`let str = "abc"`

2. Number - numeric values that are integers or floating-point numbers
`let num = 5`

3. BigInt - whole number larger than the maximum safe number a Number variable or data type can have
`let bigInteger = Number.MAX_SAFE_INTEGER`

4. Boolean - true or false value that represents a logical entity
`let bool = true`

5. Undefined - variable that has not been assigned a value
`let undefinedValue`

6. Symbol - unique identifier (rarely used from what I gathered from the lecture)
`let sym = Symbol()`

7. Null - represents a value that does not exist or is invalid

[Source](https://developer.mozilla.org/en-US/docs/Glossary/Primitive)

## Structured
Structured means that it has one or more named attributes. It can have methods or properties, unlike primitive data types.

1. Objects - a collection of key-value pairs [which can also be called map, dictionary, or hash-table in other languages](https://www.freecodecamp.org/news/data-structures-in-javascript-with-examples/). Arrays are considered an object.

`let oj { id: 1, name: cat}`


_**Fun fact**_: Functions are also considered an Object type! [See 4.3.31 in ECMA International for terms and definitions.](https://262.ecma-international.org/11.0/#sec-terms-and-definitions-function) 

There might be more examples of structured data types compared to what I went over. However, this is just the beginning! I am super excited to learn more about JavaScript.
Generative AI on Roblox
Published: 2023-03-16 00:07:38

- Roblox is incorporating Generative AI technology into their platform.
- The technology will improve the creative capabilities of users.
- Creators will be able to produce more complex and diverse content.
- Generative AI will help ensure that the content produced on the platform is safe and appropriate for all users.
- Roblox plans to explore and implement more Generative AI in the future.


Original Article can be found here: https://blog.roblox.com/2023/02/generative-ai-roblox-vision-future-creation/