teleren/devto huggingface dataset:
How to write Coinmarketcap Circulating Supply API?
Tags: coinmarketcap, coingecko
Published: 2023-02-10 09:16:30

![Coinmarketcap circulating supply api](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ni6459vrwd1n234kwwnu.png)

Listing token on COINMARKETCAP and COINGECKO require an endpoint API that return total supply and circulating supply of your token in simple numeric JSON format. Best coinmarketcap circulating supply api and coingecko circulating supply API.


[GET YOUR API](https://www.fiverr.com/sanjithacks/coinmarketcap-api-to-track-circulating-supply-total-supply)

**What is different between “Max”, “Total” and “Circulating” Supply?**
- **Max Supply** is the maximum amount of coins that can ever exist in the lifetime of a coin
- **Total Supply** is the total amount of coins that are currently in existence at this moment in time (minus any coins that have been burned).
- **Circulating Supply** is the estimated amount of coins that are currently circulating the entire market and within the general public’s hand.


Listing token on **COINMARKETCAP** and **COINGECKO** require an endpoint API that return total supply and circulating supply of your token in simple numeric JSON format. Best **COINMARKETCAP** circulating supply API and **COINGECKO** circulating supply API.


Are you looking to keep track of your token’s circulating supply and total supply while increasing its visibility in the crypto market? I have the solution for you! I can provide an API that will allow you to access the current circulating and total supply of your token on **COINMARKETCAP**.

The data returned by my API endpoints is in **numeric format**, making it easy for you to monitor and analyze your token’s supply and performance in real-time.

Whether you’re a blockchain project looking to boost your market presence or a developer seeking accurate and up-to-date token data, my API is the ideal tool.

Don’t miss this chance to take your token to the next level and increase its exposure to potential investors.

Let’s work together to make your token stand out in the crowded crypto market!


```
Related Tags:

tracking supply , cmc api, coingecko api, cg api, coinmarketcap api, circulating supply, circulating supply api, token supply api
```
7 Most Powerful AR SDKs and Frameworks for App Development
Tags: mobile, app, android
Published: 2023-02-10 09:07:40

1.7 billion is the estimated Mobile AR devices by 2024 📈

AR is becoming the new normal in this digital world.

Especially, businesses use AR for instant conversions by applying them to Mobile Apps.

But for amazing AR experiences on mobile devices, AR SDKs are a must.

Before choosing any SDK for your AR app, you need check below criteria to get best output.

Which criteria should be considered when selecting an AR SDK?
It is crucial to select the right AR SDK for developing your next AR app. Here is a list of such criteria that you need to consider before selecting the right platform. 

💡 Capability to support multiple operating systems (mainly iOS and android)
💡 Competence for Unity, the most advanced graphics and development framework   
💡 Support for Cloud recognition to enable markers without consuming large space on device
💡 Potential of 3D tracking and recognition for real-time triggers
💡 Thorough documentation for easier code explanation
💡 Support for Geo-location for location-based applications
💡 Smart-glasses support for hands-free experience
💡 Premium licensing (either restricted use by the free version or unlimited features by commercial license)

Check out the top tech stacks that support AR app development for your mobile devices.

## Top 7 Augmented Reality SDKs and Frameworks:

1⃣ ARKit
2⃣ ARCore
3⃣ Augment
4⃣ Vuforia 
5⃣ ARToolKit
6⃣ ZapWorks – Universal AR SDK
7⃣ Augmented Reality SDK (Wikitude)

Here is the comprehended comparison of all the discussed AR SDKs to help you select better: **https://bit.ly/3YCa5ot**

The AR services spending will boost by a high CAGR in AR custom app development. And it is definite that all these AR SDKs discussed here, work as the connecting link for AR content, application, and the real device. Among all the different kinds, you need to select the one that fits your project best. However, here is the comprehended comparison of all the discussed AR SDKs to help you select better.

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/8q6ldq0r6r2o5qmxxl5i.jpg)
Ace Infoway with extensive experience in having developed custom mobile applications provides you with the skills and expertise to work on any challenging mobile application development project.
How to integrate Tailwind CSS into Django
Tags: python, django, tailwindcss, webdev
Published: 2023-02-10 09:01:28

Django-Tailwind is a library that allows you to easily integrate the Tailwind CSS framework into your Django project. Tailwind is a popular, utility-first CSS framework that provides a fast and efficient way to build custom user interfaces.

Here's a step-by-step guide to using Django-Tailwind in your Django project:

Install Django-Tailwind: To use Django-Tailwind, you first need to install it using pip. Open a terminal and run the following command:

```
pip install django-tailwind
```
Add Django-Tailwind to Your INSTALLED_APPS: Next, you need to add Django-Tailwind to your INSTALLED_APPS setting in your Django settings.py file.

```python
INSTALLED_APPS = [
    # ...
    'tailwind',
]
```
Include Django-Tailwind in Your Template: To include the Tailwind CSS in your Django templates, you need to use the 

```
{% load tailwind %}
```
 tag at the top of your template file, and then include the 

```
{% tailwind %}
```
 tag where you want the CSS to be loaded.

```html
{% load tailwind %}
<!DOCTYPE html>
<html>
<head>
  <title>My Django Project</title>
  {% tailwind %}
</head>
<body>
  <!-- Your HTML goes here -->
</body>
</html>

```

Use Tailwind Classes in Your HTML: Now that you have included the Tailwind CSS in your Django templates, you can start using the Tailwind classes in your HTML. Here's an example of a simple button:

```html
<button class="bg-blue-500 hover:bg-blue-700 text-white font-bold py-2 px-4 rounded">
  Click me
</button>
```
Customize Your Tailwind Configuration: If you want to customize your Tailwind configuration, you can create a tailwind.config.js file in the root of your project. The file should contain your custom configuration, which will be used instead of the default Tailwind configuration.

```python
module.exports = {
  theme: {
    extend: {
      colors: {
        'my-custom-color': '#ff0000',
      },
    },
  },
  variants: {},
  plugins: [],
}
```
In conclusion, Django-Tailwind is a great tool for integrating the Tailwind CSS framework into your Django project. With its easy setup and integration, you can quickly and easily start using Tailwind to build custom user interfaces that look and feel great.
How to Create Decorators in Django
Tags: webdev, python, django, tutorial
Published: 2023-02-10 08:53:26

Decorators in Django are a powerful tool for adding additional functionality to your views and functions. They can be used to implement common patterns such as authentication and authorization, caching, and logging.

Here's a step-by-step guide to using decorators in Django:

Create a Decorator Function: The first step is to create a function that takes a view function as an argument and returns a modified version of the view. This function is called a decorator.

```python
def my_decorator(view_func):
    def wrapper(request, *args, **kwargs):
        # code to be executed before the view
        response = view_func(request, *args, **kwargs)
        # code to be executed after the view
        return response
    return wrapper
```
Apply the Decorator: To apply the decorator to a view, simply add the @ symbol followed by the name of the decorator before the view function definition.

```python
@my_decorator
def my_view(request):
    # code for the view
    return HttpResponse("Hello, World!")
```
Use Multiple Decorators: You can also apply multiple decorators to a single view by stacking them on top of each other. The decorators will be applied in the order they are listed.

```python
@decorator1
@decorator2
@decorator3
def my_view(request):
    # code for the view
    return HttpResponse("Hello, World!")
```
Decorating Class-Based Views: To decorate a class-based view, simply apply the decorator to the dispatch method.


```python
class MyView(View):
    @my_decorator
    def dispatch(self, request, *args, **kwargs):
        # code for the view
        return HttpResponse("Hello, World!")
```
In conclusion, decorators are a powerful tool in Django for adding additional functionality to your views and functions. They can be used to implement common patterns and improve the structure and maintainability of your code.
GetBlock Scores Infrastructure Partnership with Pocket Network
Tags: webdev, devops, node, api
Published: 2023-02-10 08:30:35


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/omq99immj091oy8p6l49.png)
[GetBlock](https://getblock.io/) and[ Pocket Network](https://www.pokt.network/)'s infrastructure collaboration will add enhanced RPC APIs to their work toolkit once the integration is complete.
This partnership will allow the Pocket Network and GetBlock to work together to create new products and features for their users.

dApps need web 3.0 nodes to function since they don’t have to run their own nodes.

Pocket Network’s node runners provide significant capacity to the network. The need for POKT tokens is spurred by various projects, apps and other services that use the Pocket ecosystem. Buyers of the token can pay regular fiat money to purchase POKT. Additionally, many people buy POKT in order to participate in projects and services that require node capacity.

In 2019, GetBlock launched a service that provides users access to 40+ blockchains. These include testnets and mainnets, which can be used for dedicated or shared nodes. Many different packages are available for GetBlock services, including MetaMask web3 authorization.
Dynamically typed languages
Tags: webdev, programming, beginners, computerscience
Published: 2023-02-10 08:15:30

Languages with dynamic typing do not require type declarations, but they also do not perform type inference. The types of variables are unknown until they have concrete values at runtime. For example, the Python function:

`def function(x, y):
    return x + y`

can add integers, concatenate strings, concatenate lists, etc., and we cannot determine which will happen without actually running the program. It's possible that f will be called with strings at one point and integers at another, in which case x and y will hold values of different types at different times. This is why we say that values in dynamic languages have types, but variables and functions do not. The value 1 is clearly an integer, but x and y in the example may be anything.
PostgreSQL Data Generator
Tags: postgres, dbforge, devart
Published: 2023-02-10 08:09:06

---
title: PostgreSQL Data Generator
published: true
description:  dbForge Data Generator for PostgreSQL Overview
tags: #postgresql #postgres #dbforge #devart
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-02-03 14:24 +0000
---
Testing is one of the most important procedures in the process of creating a high-quality product. The dbForge Data Generator for PostgreSQL is designed to generate huge amounts of realistic, meaningful test data. This makes it possible to convert unexpected database errors into preventable events. Let's take a deeper look - https://www.devart.com/dbforge/postgresql/studio/data-generator.html
![Data Generator](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/323ai5tip25rq76409yh.png)
Hashable vs Immutable Objects in python
Tags: python, immutability, hashable, datastructure
Published: 2023-02-10 07:38:07

---
title: Hashable vs Immutable Objects in python
published: true
description: 
tags: python, immutability, hashable, datastructure
# cover_image: https://miro.medium.com/v2/resize:fit:1400/0*vU26HDmNW6-LrI7M
# Use a ratio of 100:42 for best results.
# published_at: 2023-02-09 05:52 +0000
---
![image](https://miro.medium.com/v2/resize:fit:1400/0*vU26HDmNW6-LrI7M)
In Python, two important concepts to understand are hashable and immutable objects. These concepts determine how objects are stored and manipulated in memory, and they have a significant impact on the performance and functionality of our code.

## Hashable Objects:

A hashable object is an object that has a hash value that never changes during its lifetime. This means that its value can be used as a key in a dictionary or as an element in a set. Examples of hashable objects in Python include integers, floating-point numbers, strings, and tuples (if they contain only hashable elements).

When you try to use an unhashable object as a key in a dictionary, Python will raise a TypeError. For example, lists are unhashable, so you cannot use them as keys in a dictionary:
```
d = {[1, 2, 3]: "list"}  # Raises TypeError
```
Python has a built-in hash method ( __hash__() ) that can be used to compare other objects. If the hashable objects are equal then they have the same hash value.

```
print(hash(5))           # 5

print(hash("hello"))     # 6089416059157437065

print(hash(2+3))         # 5

print(hash("hello"))     # 6089416059157437065
```

## Immutable Objects:

An immutable object is an object whose state cannot be changed after it is created. This means that once you create an object, you cannot modify its value. Examples of immutable objects in Python include integers, floating-point numbers, and strings. All immutable built-in objects in Python are hashable like tuples while the mutable containers like lists and dictionaries are not hashable.

The advantage of using immutable objects is that they are safer to use in concurrent environments, as their state cannot be changed by another thread. This makes them easier to reason about and less prone to bugs.

On the other hand, mutable objects (such as lists and dictionaries) are more flexible and can be used for more complex data structures, but they can be harder to understand and debug when used in concurrent environments.

[Checkout my other article about immutables in python.](https://dev.to/himankbhalla/why-should-i-care-about-immutables-in-python-4ofn)

Conclusion:

In conclusion, understanding the difference between hashable and immutable objects is crucial for writing efficient and maintainable Python code. When choosing between mutable and immutable objects, consider the requirements of your code and the trade-offs between flexibility and safety. In general, it is recommended to use immutable objects whenever possible, as they are easier to understand and less prone to bugs.
Abigail Shapiro: Biography | Datanfact
Tags: github, abigailshapiro
Published: 2023-02-10 07:16:14

[Abigail Shapiro](https://www.datanfact.com/abigail-shapiro-age-height-professional-life-social-media-popularity/
) is a contemporary Jewish writer and speaker. She was born and raised in Los Angeles, CA. She earned a B.A. in English from University of California at Berkeley and an MFA in Creative Writing from New York University. She has worked as a short story writer, editor, screenwriter, and novelist. Her most recent book is the novel The Way Home. Her essays have appeared in anthologies including Best American Essays and The New American Novel, and her essays have been translated into several languages and used as inspiration for other creative works.
Challenge #0: 🎟 Simple NFT Example
Tags: web3, blockchain, solidity, javascript
Published: 2023-02-10 07:09:27

## Tasks to be done

🎫 Create a simple NFT to learn basics of 🏗 scaffold-eth. You'll use 👷‍♀️ [HardHat](https://hardhat.org/getting-started/) to compile and deploy smart contracts. Then, you'll use a template React app full of important Ethereum components and hooks. Finally, you'll deploy an NFT to a public network to share with friends! 🚀

🌟 The final deliverable is an app that lets users purchase and transfer NFTs. Deploy your contracts to a testnet then build and upload your app to a public web server.

## My Review

I would not class this as a challenge but more like getting accustomed with the setup and tools being used. For beginers in web3, this is a great way to understand how smart contracts are written, compiled, tested and deployed 🚀 Beginers should use this challenge to experiment and practice writing solidity which they might have learned recently but if you have written smart contracts in the past you can get used to the setup and quickly move on to the next challenge.

## Important links

- [Speed Run Ethereum](https://speedrunethereum.com/challenge/simple-nft-example)
- [Deployed webapp](https://kevinj-sre-c0.surge.sh/)
- [Deployed contract](https://goerli.etherscan.io/address/0xd3628c08de1a2788c232732bb06de8dbdae1a3e7)
- [Project source code](https://github.com/kevinjoshi46b/speedrunethereum/tree/master/challenge-0-simple-nft)
Why did a GPT-powered SQL generator write a fake SQL statement in response to my question?
Tags: ai, gpt3, sql
Published: 2023-02-10 07:00:31

My question was "TiDB vs MySQL" and it generated the SQL below.

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

This is the question link:  https://ossinsight.io/explore/?id=ab3ed547-01eb-4e7e-b70e-ff70c8836af9
Pair & Mob Programming - Any experience?
Tags: discuss, watercooler
Published: 2023-02-10 06:59:46

In my company, we mostly don't do pair or mob programming ([Wikipedia](https://en.wikipedia.org/wiki/Mob_programming)).
However, one team does it from time to time, and they advocate for it.

They presented their way of working, and it seems interesting.
As many other advocate of pair programming, they swear it is time efficient and productive.
Especially, because there are no code reviews because all of the code is automatically reviewed. No more PRs, and additionally, this type of evaluation is probably far superior to your typical PR.

However, I feel it could slow down development when devs are not at a similar level. Is it the case?

Do you have any direct experience?
cuocesport com ⭐️ là nơi cung cấp những thông tin uy tín
Published: 2023-02-10 06:52:55

"cuocesport com ⭐️ là nơi cung cấp những thông tin uy tín nhất trên cộng đồng Việt Nam hiện nay. Các thủ thuật khi chơi game, cách đặt cược thể thao, esport, liên minh huyền thoại, csgo, dota2, nổ hũ, bắn cá.... #cuocesport, #LOL, #dota2, #esport, #thể thao điện tử, #giải trí, #gamebai
Website: cuocesport.com 
Địa chỉ:  285 Nguyễn Khoái, Bạch Đằng, Hai Bà Trưng, Hà Nội, Việt Nam"
"CUOCESPOT là trang web chuyên cung cấp các địa chỉ cá cược uy tín. Không chỉ vậy, trang web thường xuyên đăng tải các mẹo và thủ thuật để giúp người đặt cược có thêm kinh nghiệm trong môn thể thao độc đáo này. Vì vậy, nếu bạn cần trang web và trò chơi siêu thông minh này, hãy chú ý đến nó
Cá cược thể thao điện tử hay cá cược thể thao điện tử nói chung là một hình thức tham gia cá cược trực tuyến về các môn thể thao thi đấu mà người tham gia tham gia."
https://www.facebook.com/profile.php?id=100089818047043
https://twitter.com/cuocesport
https://www.youtube.com/channel/UCHYW2vzypER2xPGj5uIRCyQ
https://www.tiktok.com/@cuocesport?lang=vi-VN
https://www.twitch.tv/cuocesport
https://github.com/cuocesport
https://worldcosplay.net/member/1133301
https://account.riotgames.com/#personal-information
https://account.garena.com/?locale_name=VN
https://steamcommunity.com/id/cuocesport
https://research.openhumans.org/member/me/

https://artmight.com/user/profilesettings
https://justpaste.it/u/cuocesport
https://vnvista.com/forums/index.php?act=module&module=network&cmd=guestbook&mid=109599
https://qooh.me/cuocesport
https://www.speedrun.com/user/cuocesport

https://flipboard.com/profile
https://osf.io/4snkf/wiki/home/
https://linktr.ee/admin
https://cuocesport.blogspot.com/2023/02/cuocesport-com-la-noi-cung-cap-nhung.html
https://replit.com/@cuocesportcuoce
https://discord.com/channels/1073490698210377798/1073490698684354581
C# - Improving Array Performance with .NET 7
Tags: csharp, dotnet, memory, programming
Published: 2023-02-10 06:46:35

.NET 7 introduced a new static class called [NativeMemory](https://learn.microsoft.com/en-us/dotnet/api/system.runtime.interopservices.nativememory), which can be used to allocate unmanaged memory.

Normally when working with arrays in C#, the .NET runtime manages the allocation of memory and frees it when it's no longer used, hence the name managed memory.

When using `NativeMemory`, you're on your own. The .NET garbage collector won't free it when you no longer need it, and the .NET runtime won't perform bounds checks when reading or writing to it. The advantage is it's faster to work with as the bounds checks performed by .NET aren't present.

> Warning! Allocating 1024 integers and then writing to the 1025th one will overwrite memory that may be in use elsewhere. Be careful!



## Usage

Allocate a 1kb block of unmanaged memory:
```
var byteCount = 1024;
void* data = NativeMemory.Alloc(byteCount);
```

Allocate and zero a block of unmanaged memory:
```
void* data = NativeMemory.AllocZeroed(1024);
```

Resize a block of unmanaged memory to 2kb:
```
NativeMemory.Realloc(data, 2048);
```

Free a block of unmanaged memory:
```
NativeMemory.Free(data);
data = null;
```



## Example - Accumulating an Array

Using managed memory:
```
// Allocate managed memory
const int LENGTH = 1024;
int[] data = new int[LENGTH];


// Accumulate
int total = 0;

for (int i = 0; i < LENGTH ; i++)
    total += data[i];


// Log the result
Console.WriteLine(total);
```

Using unmanaged memory:
```
// Allocate unmanaged memory
const int LENGTH = 1024;
int byteCount = LENGTH * sizeof(int);
int* data = (int*)NativeMemory.Alloc(byteCount);


// Option 1
// - Same syntax as the managed example
int total = 0;

for (int i = 0; i < LENGTH; i++)
    total += data[i];


// Option 2
// - Different syntax, same functionality
for (int i = 0; i < LENGTH; i++)
    total += *(data + i);


// Option 3 - 
// - Make a copy of the data pointer, read from it, then increment it
// - This works because pointers are essentially a 32 or 64 bit
//   integer, meaning we can increment and compare them
var readPtr = data;
var endPtr = data + LENGTH;

while (readPtr < endPtr)
{
    total += *readPtr;
    readPtr++;
}


// Log the result
Console.WriteLine(total);
```



## Benchmarks

The above managed and unmanaged examples were benchmarked using [BenchmarkDotNet](https://github.com/dotnet/BenchmarkDotNet), with an array length of 32768.

![Time required to accumulate a managed array vs an unmanaged array. 12.538us average time for managed, 9.616us average time for unmanaged.](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/tj4g0mxjcaxr6a0w70e6.png)