teleren/devto huggingface dataset:
A Solution for Non-Mac Developers to Submit iOS Apps
Published: 2023-07-28 07:12:23

Non Apple Developer's iOS application launch solution

When launching iOS applications, we usually need to use Apple's Application Loader. Although this tool greatly helps developers to complete the application launch, it can only be used on Mac computers and has limited usage environments.

Nowadays, many developers create applications through other development platforms without building a Mac environment, and encounter obstacles when uploading applications. Some developers request help from friends who own Mac computers to put them on the shelves, while others turn to Taobao to find someone to do the work, or to build virtual machines in Windows systems, try methods such as black Apple. However, these methods are not convenient enough and consume a lot of time, reducing efficiency.

Fortunately, with Appuploader now available, it can be used directly on Windows, Linux, or Mac, providing great convenience for developers. Most importantly, it is still free and can be shared with developers who have needs.
Tool Homepage: [App Uploader](https://www.applicationloader.net/)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/4u3424ees7gri8kibdul.png)
Reflections on the 2021 NFT Summer Boom and NFT Portfolio Tracking
Tags: nft, blockchain, web3, dapp
Published: 2023-07-28 07:11:19

In the summer of 2021, we witnessed an unparalleled surge in the NFT (Non-fungible Tokens) market, the likes of which had not been seen before. The trading volume soared to such an extent that it was a staggering ten times higher than the current volume we see today. This period, fondly remembered as the NFT summer boom, created a wave of new digital art collectors, tech enthusiasts, and crypto investors who flocked to various NFT platforms to mint, buy, and trade unique digital assets.

For those of you who participated in this unprecedented phenomenon, you may find yourself pondering a question: Have you HODLed (Hold On for Dear Life) the NFTs you minted during that period?

In retrospect, the decision to hold or sell can influence the value of your portfolio significantly. It's natural to wonder if you've made the right choice, particularly with the fluctuations and volatility often associated with the NFT and broader crypto market. To answer this question, we need to know the current worth of our NFT portfolios and how they have performed over time.

Enter NFTGo, an innovative NFT data platform that addresses this exact need. It provides an insightful function that enables users to view the profit and loss status of each wallet address. This feature allows NFT holders to monitor the performance of their digital assets efficiently and make informed decisions about potential future transactions.

Moreover, the good news for developers and those who wish to incorporate this functionality into their applications or platforms is that NFTGo offers a comprehensive API for this service. The API documentation available at https://docs.nftgo.io/reference/get_metrics_eth_v2_address_metrics_get gives a detailed overview of how to integrate this feature and fetch wallet metrics. It's a valuable tool that can greatly help both individual users and businesses in their quest to understand and navigate the often complex world of NFTs.

To use their API, you need to first visit NFTGo's developer platform at https://developer.nftgo.io/developers. After registering and obtaining your API key, you will have access to the functionalities it offers. This ease of access ensures a seamless integration process, allowing both individual users and businesses to harness the power of data and make the most of their NFT investments.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/wf7ojbrwkwuze81wtatv.png)
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bjn2u5j2got9g7bvc5qa.png)
🩷 Need More love to Flutter Web
Tags: flutter, web, seo
Published: 2023-07-28 07:08:44

Flutter is the emerging technology that developers are increasingly turning to when creating mobile applications. but as evident in the more recent market. Developers can now improve the website using the same code by using a new feature added to Flutter Web. 
Since I have been developing applications for the past 4 years, I have developed a strong interest in mobile applications. I began my adventure with Java, moved on to Kotlin, and have recently been following the lead of Flutter Development. Flutter has been quite beneficial and motivational for me, inspiring me to pursue both Android and iOS development.
Flutter demonstrated to me how a simple application could be created with little expertise, less time, and greater output.
I've been using this framework for more than a year at this point. It gave me hope that I could learn more from it. 
I've been experimenting with Flutter Web lately, and the results have been mixed. It excels at what it does, but more care is still needed to maximize the potential it has generated within mobile development. Flutter Web performs well on the web and the hosting aspect is also very simple and quick. The developer community can follow the very promising route that Flutter Web has demonstrated.
These are a few of the web applications using the flutter framework that I have been working on and are still under development.


**[Event Anything](https://flutter.eventanything.com)**

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


[Personal Portfolio](https://brishavshakya.com.np)


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



## Enhancements
Working on Flutter Web has seriously hindered the website's responsiveness, and neither a plugin nor a package appears to have a workable solution. Some of the essential plugins, like Listview and Gridview, require greater compatibility rather than relying on math to be responsive.
Although certain packages have been seen to be constructed, they are not yet stable enough to work with.
Flutter web can shine more like it has in the mobile zones if the devs can work on this and show a little more affection.
Unravel Your Coding Passion: What Sparks Your Excitement?
Tags: discuss, career, beginners, codenewbie
Published: 2023-07-28 07:00:00

_Welcome to "Discover Your Code," guided by our official DEV moderator, Sloan the Sloth 🦥. This series is designed to help aspiring coders and students explore the coding universe, ignite their passion, and find their ideal career paths._

Today's question is:

> What specific aspects of coding and development ignite your passion and curiosity?

Responses from newbies and experienced devs alike are encouraged in order to broaden our horizons and showcase different POVs.

Follow the [CodeNewbie Org](https://dev.to/codenewbieteam) and [#codenewbie](https://dev.to/t/codenewbie) for more discussions and online camaraderie!

*{% embed* https://dev.to/codenewbieteam *%}*
How Does Python's Readability Affect Newcomers' Learning Curve?
Tags: discuss, python
Published: 2023-07-28 07:00:00

Python is known for its readability and simplicity. How does this aspect affect the learning curve for newcomers to programming?

Follow the DEVteam for more discussions and online camaraderie!

{% embed [https://dev.to/devteam](https://dev.to/devteam) %}
Mastering Git Shortcuts: A Guide to Git Aliases
Tags: git, opensource, programming, beginners
Published: 2023-07-28 06:59:13

Are you tired of typing lengthy Git commands? Git aliases are here to save the day! They let you establish shortcuts for common commands, thus enhancing your productivity. 

Let's explore two ways to set them up.

**Method 1: Git Config Command**

> Before starting, make sure you have Git installed.

Initially, you can utilize your terminal:

```bash
git config --global alias.<alias-name> '<git-command>'
```

In this command, substitute `<alias-name>` with your preferred alias, and `<git-command>` with the actual Git command. For example:

```bash
git config --global alias.co 'checkout'
git config --global alias.st 'status'
```

**Method 2: Editing the `.gitconfig` File**

Another approach involves making adjustments directly in your .gitconfig file, which is usually found in your home directory and add the following:

```bash
[alias]
  st = status
  co = checkout
  hist = log --pretty=format:\"%h %ad | %s%d [%an]\" --graph --date=short
```

The first method also adds to the `.gitconfig` file, but directly editing the file tends to be a simpler process.

With these set up, you can now use `git co` in lieu of `git checkout`, and `git st` instead of `git status`. It's important to remember, these aliases are only applicable to your local machine.

Some users also prefer creating aliases in `.bashrc` or `.zshrc` files to abbreviate them even further, such as using `gs` for `git status` and `gc` for `git checkout`.
Are you tired of connecting your android device every time? Then build your own DeviceFarm🏭.
Tags: opensource, testing, automation, productivity
Published: 2023-07-28 06:46:38

Are you developing a mobile app? If you're developing a mobile app, you're likely carrying an Android or iOS device and a USB cable.

## Journey to install the app
To do Android testing, you will need a USB-C or USB-B cable compatible with your PC. And you need to set up USB Debugging on your Android device. And you need to connect your Android device to your PC. Now install the app with the adb install command.
What if I want to connect another device? You will need to purchase a new cable for the device and repeat the above process.
What if you change your seat? You should also carry your test device and cables with you.


<img width="100%" style="width:100%" src="https://media.giphy.com/media/v1.Y2lkPTc5MGI3NjExZGpnNWp2bjZ1czJybmdsdHVrZnNkZW9tbGY3MmswNXdobGJwNjJsZCZlcD12MV9pbnRlcm5hbF9naWZfYnlfaWQmY3Q9Zw/K25PVRA032Ues/giphy.gif">


## Set it up once and always leave it ready.
The above USB connection is very cumbersome, but it is an unavoidable process to test the app before distributing it. You can't get rid of the above process, but what if you only do it at initial setup and make it ready?
In this case, you can use Device Farm.

## If you use Cloud Device Farm
Currently, there are many Cloud Device Farms(Browserstack, Lambdatest, Perfecto, Headspin, testsigma). You can use Cloud Device Farm like this. However, this Cloud Device Farm is not suitable for this case.
- If you do not want to expose your test app, there is a possibility that the app can be exposed if you install and test the app on the Cloud Device device.
- If you don't want to spend a lot of money on testing, Cloud Device Farm can be expensive.
- If you access the Cloud Device from a physically distant distance, there may be a latency in accessing the Cloud Device Farm and controlling the device.

## Build your own Device Farm
Building DeviceFarm on-premise can solve the above problems.
Here's an open source project to build Device Farm on-premise. => [Dogu](https://github.com/dogu-team/dogu)
- All devices are yours, so you don't have to worry about leaking test apps.
- Building DeviceFarm via the Dogu Community version is free of charge.
- Selenium, Appium integration is possible. You can test anytime, anywhere through devices connected to the device farm you built.
【Tool Sharing】iOS App Submission Assistant: Share with Non-Mac Developers
Tags: ios, apple, ipad
Published: 2023-07-28 06:45:17

Nowadays, when it comes to submitting iOS apps, developers often rely on Apple's Application Loader. Although this tool is great for app submission, it can only be used on Mac computers, limiting its usability.
Many developers create applications using other development platforms and do not have access to a Mac environment. This creates obstacles when trying to upload their apps. Some developers ask friends with Mac computers for help, while others resort to hiring people on platforms like Taobao or setting up virtual machines on Windows systems to run macOS, which can be inconvenient and time-consuming, resulting in reduced efficiency.
However, there is a solution called Appuploader. This tool allows developers to directly use it on Windows, Linux, or Mac, providing much-needed convenience. The best part is, it is free to use and can be shared with developers who are in need.
Tool Homepage:[ App Uploader](https://www.applicationloader.net/)
The DOM: A Simplified Explanation
Tags: javascript, beginners, html, codenewbie
Published: 2023-07-28 06:37:51

The Document Object Model, or DOM, can be a difficult concept to grasp, both in understanding what it is and how to use it. This post will attempt to explain both in a way that beginners, like myself, can understand and put to use. 

**What is the DOM?**
The DOM is the object a browser creates when a web page is loaded. It is a language-neutral platform that allows programs to interact with HTML. Without the DOM, JavaScript would have no way to change web page information using an external database, take in information from a form, or display extra details when a user clicks on an image. 

The DOM is a combination of HTML, CSS, and JavaScript to give the web page user a full experience with styling and interactivity. Think of the DOM as a house. HTML is the foundation and frame of the house. The house wouldn’t be standing without the HTML structure, but it’s nothing unique to the person living in the house. CSS is the aesthetics, like paint or door and window styles. It makes the house structure more personalized, but it doesn’t make it a home for the resident. Lastly, the JavaScript is the appliances in the house that the resident can actually interact with, such as the kitchen stove, the washing machine, or the refrigerator. All of these appliances help the resident interact with the space and make it into a usable home. 

**How Does it Work?**
Continuing with our house analogy, different appliances need to be in certain places for the best use. With JavaScript, we need to tell the code where we want our functionality placed in the HTML structure. Let’s say we have an image that we want to feature on a site. First, determine where in the HTML the image needs to be placed. In this case, we’ll choose the div with an Id of feature-image. 

```
<div id=”feature-image”></div>
```

In order to reference this div element in JavaScript, use the getElementById method and pass in the element id. 

```
const imgDiv = document.getElementById(“feature-image”)
```

Next, since there isn’t a field in the div to display the image, we need to add one using the createElement method and pass in the specific HTML tag.

```
const featImg = document.createElement(“img”)
```

This code specifies what should be in the image field, such as the source and alternative information. 

```
featImg.src = “https://www.images.com/colosunset”
featImg.alt = “Colorado Sunset”
```

Finally, we need to tell the code where to put the new image tag. This appends the featImg tag and related code to the imgDiv so the HTML structure can now reference it. 

```
imgDiv.appendChild(featImg)
```


“The HTML DOM (Document Object Model).” JavaScript HTML Dom,
 www.w3schools.com/js/js_htmldom.asp. Accessed 27 July 2023.
A Guide to Cache Storage in JavaScript: Boosting Performance with Caching
Tags: javascript, webdev, performance, api
Published: 2023-07-28 06:29:08

In modern web development, optimizing website performance is crucial for providing a smooth and efficient user experience. One powerful technique to achieve this is by leveraging caching mechanisms. JavaScript offers a powerful API called **Cache Storage**, which allows developers to store and manage cached responses, reducing server load and speeding up page loading times. In this article, we'll delve into the world of Cache Storage and explore how it can be implemented to boost the performance of your web applications.

## What is CacheStorage?

Cache Storage is an API that forms a part of the Service Worker API in JavaScript. It provides a mechanism to cache network responses and assets, making them available for retrieval later without the need to make a new network request. By storing responses locally, subsequent requests for the same resources can be handled faster, leading to improved page load times and reduced data usage.

## The Benefits of Caching
- Faster Load Times
- Offline Support
- Reduced Bandwidth

## Working with CacheStorage

```javascript
// Register the service worker
if ('serviceWorker' in navigator) {
  navigator.serviceWorker.register('/service-worker.js')
    .then(() => {
      console.log('Service worker registered.');
    })
    .catch((error) => {
      console.error('Error registering service worker:', error);
    });
}

// Cache a response
self.addEventListener('install', (event) => {
  event.waitUntil(
    caches.open('my-cache')
      .then((cache) => {
        return cache.addAll([
          '/',
          '/styles.css',
          '/app.js',
          '/logo.png',
          // Add other assets to cache here
        ]);
      })
  );
});

// Intercept fetch requests and serve from cache if available
self.addEventListener('fetch', (event) => {
  event.respondWith(
    caches.match(event.request)
      .then((response) => {
        return response || fetch(event.request);
      })
  );
});

```
## Conclusion
Cache Storage in JavaScript is a powerful tool for improving website performance by caching responses and assets. By leveraging the caching mechanism, you can significantly reduce page load times, provide offline support, and conserve bandwidth. However, it's essential to use caching judiciously and update cache entries when resources change to ensure users receive the latest content. With the right implementation, Cache Storage can be a game-changer in optimizing web applications and providing users with a seamless experience.
What makes PostgreSQL king of databases
Tags: postgres, database, softwareengineering
Published: 2023-07-28 06:27:43

According to the StackOverflow survey, PostgreSQL is the most loved database in 2022. What makes it so special? I mean it is just another SQL database, right? let’s find out

Well first, let's clear out that PostgreSQL is ACID-compliant which is the primary requirement of relational databases and it supports foreign keys, stored procedures, joins, and views too just like MySQL

When we think of relational databases, MySQL is the first thing that comes to mind. When we google MySQL vs PostgreSQL, it spits out “MySQL is a purely relational database, whereas PostgreSQL is an object-relational database.”

Object Relational Database?
Objects, Classes and Inheritance are directly supported in database schemas and in the query language. In addition, just as with pure relational systems, it supports extension of the data model with custom data types and methods. This is what makes PostgreSQL so useful, it helps in solving several use cases that would have otherwise required us to learn new database systems like

**OLTP (Online Transaction Processing):**
Traditional CRUD (Create-Read-Update-Delete) operations.

**OLAP (Online Analytical Processing):**
OLAP is used by data engineers to analyze and get insights into data.
Since PostgreSQL is based on HTAP (Hybrid transactional/analytical processing) architecture, it can handle OLAP pretty well.

**FDW (Foreign Data Wrapper):**
We can create or use FDW to connect to different databases like Redis, MySQL, Neo4j and perform data flow operations.

**Streaming:**
PipelineDB extended from PostgreSQL is a time series database that can be used for real time reporting and analytics applications.

**Geospatial:**
PostGIS is a spatial database extender for PostgreSQL. It adds support for geographic objects, allowing location queries to be run in SQL.

**Time Series:**
Timescale extended from PostgreSQL for time series and analytics. It is used to combine relentless streams of financial and tick data with other business data to build new apps and uncover unique insights.

**Distributed Tables:**
Distributed Tables are tables whose rows are spanned across multiple tables to speed up read and write operations. This is done using a consistent hashing technique. CitusData extended from PostgreSQL gives this feature out of the box
How to add new changes to most recent git commit?
Tags: git
Published: 2023-07-28 06:25:21

_📝 This post is part of my ["Shorts"](https://poddarayush.com/shorts) series. Each post in this series is hyper-focused on a single concept and should take less than 1 minute to read._

If you’ve ever used Git for version control, you may have come across a situation where you realise that you’ve made a mistake in your last commit and want to fix (modify) it. You could create a new commit with the fix or you could **modify the existing commit and keep your commit history clean**.

How to edit your most recent (last) commit?
-------------------------------------------

The git command to be used is:

```
git commit --amend
```


### More about `git commit --amend`

This is a powerful git command which allows you to modify the most recent commit. By using this command, you can combine any staged changes into the most recent commit.

For all you care, it edits the commit. But, under the surface, it replaces the most recent commit with a new commit, which has the combined changes. This means that the amended commit becomes a new entity with its own reference.

### Changing the commit message of the most recent commit

This command can also be used to change the commit message of the most recent commit. Running the command, `git commit --amend`, will open your text editor and allow you to edit the commit message.

Else, you can also use the `-m` flag with the new commit message, bypassing the need to open your text editor.

```
git commit --amend -m "A better commit message"
```

### What if there are no staged changes?

You can use this command to just edit the commit message of the most recent commit.

### Keeping the same commit message

When git opens the text editor after you run the `git commit --amend` command, you can just save and close the editor to keep the same commit message.

Else, you can use the `--no-edit` flag to tell git to amend the most recent commit without changing its commit message. This will tell git not to open the text editor.

```
git commit --amend --no-edit
```


Final words
-----------

`git commit --amend` is a powerful tool for software developers who want to keep their git commit history clean. A git clean history, apart from looking _clean_, also helps you navigate your repository’s history easily by showing you the relevant final changes only.

Sources
-------

*   [https://www.atlassian.com/git/tutorials/rewriting-history](https://www.atlassian.com/git/tutorials/rewriting-history)
Dark theme with css
Tags: beginners, css, webdev, tutorial
Published: 2023-07-28 05:48:55

Hello world, this is my first blog post.🥳

I've spent the last few days to find an easy way to create dark and light themes using css.

With the help of [prefers-color-scheme](https://developer.mozilla.org/en-US/docs/Web/CSS/@media/prefers-color-scheme) we can create our own theme for dark or light mode.

```
prefers-color-scheme
```
That will be use with a media query, to detect if the user has their system set to use a light or dark color theme.

![CSS Media Query](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fsptlqcjr21s4c5ls06k.PNG)

Now, comes to the question of how to test the whole thing?

## Test

Current browsers read the theme preference from the operating system. Luckily there is a way to test this easily.

Tested with Google Chrome Version 115.x(July 2023).

1. Open developer tools
2. Open Command Control
  - Ctrl + Shift + P (Windows)
  - Command+Shift+P (Mac)

3. Enter Show Rendering
 * ![Enter Show Rendering](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/lsow6pqsquqjz7tniq0u.png)

4. Emulate CSS Media
 * ![Emulate CSS Media](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/gmrjs5u97gtka8cerzek.png)

## Where does it work?

Thanks to the site [caniuse.com](https://caniuse.com/?search=prefers-color-scheme) we can check CSS commands, there we get a global coverage of 94.93% for prefers-color-scheme (as of July 2023).