teleren/devto huggingface dataset:
Creating a Mobile App with Ionic and Vue.js 🚀📱
Tags: ionic, vue, mobile, tutorial
Published: 2024-05-06 08:00:00

---
title: Creating a Mobile App with Ionic and Vue.js 🚀📱
published: true
description: Learn how to build a mobile application using the Ionic framework and Vue.js. This comprehensive guide covers the integration of Vue.js with Ionic, enabling you to create cross-platform mobile apps with ease.
tags: ionic, vuejs, mobile, tutorial
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p720fm9njgk0loc7uyyl.png

# Use a ratio of 100:42 for best results.
published_at: 2024-05-06 08:00 +0000
---

Creating a Mobile App with Ionic and Vue.js 🚀📱

Ionic, coupled with Vue.js, provides a powerful framework for developing cross-platform mobile applications. In this tutorial, we'll walk through the steps of creating a mobile app using Ionic and Vue.js. By the end of this guide, you'll have the knowledge to build mobile applications that run seamlessly on both iOS and Android.

## 1. **Install Ionic CLI and Create a New Vue Project**

Start by installing the Ionic CLI globally on your machine:

```bash
npm install -g @ionic/cli
```

Now, create a new Ionic Vue project:

```bash
ionic start ionic-vue-app blank --type=vue
```

Follow the prompts to configure your project.

## 2. **Explore the Ionic Vue Project Structure**

Navigate into your newly created project and familiarize yourself with the project structure. Pay special attention to the `src` directory, which contains the Vue components and assets.

```bash
cd ionic-vue-app
```

## 3. **Run Your Ionic Vue App Locally**

Launch your Ionic Vue app locally to preview it in your browser:

```bash
ionic serve
```

View your app by navigating to `http://localhost:8100` in your browser.

## 4. **Add Ionic Components to Your Vue App**

Explore the Ionic component library and enhance your app by incorporating components like buttons, cards, and navigation elements. Update your Vue components in the `src` directory to include these Ionic components.

## 5. **Test Your App on Mobile Devices**

Use the Ionic DevApp to test your mobile app on actual devices. Download the Ionic DevApp from the App Store or Google Play, and follow the instructions to connect your mobile device to the development server.

```bash
ionic serve --devapp
```

## 6. **Build and Deploy Your Ionic Vue App**

When you're satisfied with your mobile app, build it for production:

```bash
ionic build
```

This generates a `www` directory with the compiled assets.

## 7. **Explore Deployment Options**

Explore different deployment options for your Ionic Vue app. You can use services like Firebase, Netlify, or deploy the app directly to app stores for iOS and Android.

## Conclusion: Vue.js and Ionic - A Dynamic Duo for Mobile Development 🚀📱

You've successfully created a mobile app using the powerful combination of Vue.js and Ionic. This dynamic duo empowers developers to build cross-platform mobile applications with ease. Explore further, add features, and tailor your mobile app to cater to your users' needs. Happy coding with Vue.js and Ionic! 🌐✨
InnOlympics Hackathon 2024
Tags: hackathon, webdev
Published: 2024-05-06 07:57:52

## My First Hackathon !! One of the Top 10 Finalists
Very grateful for having this opportunity ^_^ 


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

![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/fo1uizhtfcd4usk6kr4p.png)
Weekly Roundup 051 (Apr 29): 🔥Hot Topics🔥 in #workplace, #sharepoint, and #powerplatform
Tags: roundup, workplace, sharepoint, powerplatform
Published: 2024-05-06 07:55:45

Hey fellow developers! It's @jaloplo, here to give you the latest scoop on what's been happening in the [#workplace](https://dev.to/t/workplace), [#sharepoint](https://dev.to/t/sharepoint), and [#powerplatform](https://dev.to/t/powerplatform) communities. 😎

## [#workplace](https://dev.to/t/workplace)

- [How can the workplace productivity be enhanced?](https://dev.to/richamishra/how-can-the-workplace-productivity-be-enhanced-13g8) by [Richa Mishra](https://dev.to/richamishra)

## [#sharepoint](https://dev.to/t/sharepoint)

- [Getting to Know Organization News Site in SharePoint Online](https://dev.to/jaloplo/getting-to-know-organization-news-site-in-sharepoint-online-19ag) by [Jaime López](https://dev.to/jaloplo)
- [Use the Dashboard from the PnP reusable controls](https://dev.to/guidozam/use-the-dashboard-from-the-pnp-reusable-controls-3k3c) by [Guido Zambarda](https://dev.to/guidozam)

## [#powerplatform](https://dev.to/t/powerplatform)

- [Power Automate - 4 Steps to Building a Flow](https://dev.to/wyattdave/power-automate-4-steps-to-building-a-flow-36c0) by [david wyatt](https://dev.to/wyattdave)
- [Automation Duel: Power Desktop and Power Cloud Face-Off](https://dev.to/balagmadhu/automation-duel-power-desktop-and-power-cloud-face-off-4n8f) by [Bala Madhusoodhanan](https://dev.to/balagmadhu)

> *Are you well-acquainted with SharePoint, Microsoft Teams, or OneDrive and their capacity to enhance employee value? Familiar with the intricacies of Power Apps, Power Automate, or other Power Platform services? Concerned about the Workplace experience and eager to share insightful perspectives?* 
> 
> *Let's harness your expertise to create valuable content! I'm on the lookout for collaborators to co-author insightful articles and support others. 🚀💼 Connect with me on [Twitter](https://twitter.com/jaloplo), [Mastodon](https://techhub.social/@jaimelopezlopez) or [LinkedIn](https://www.linkedin.com/in/jaimelopezlopez/). Feel free to send me a message!*


That's all for this week's roundup! Thanks for tuning in, and remember to keep the discussions lively and informative in our tags. 💬 If you have any suggestions for future topics, feel free to drop them in the comments below. See you next week! 👋
Understanding Event Loop with an Interview Question
Tags: javascript, webdev, programming, beginners
Published: 2024-05-06 07:41:36

Here is the JS code, you have to guess the output. Also, you have to mention why that particular output

`
console.log('A');
setTimeout(() => console.log('B'), 0);
Promise.resolve().then(() => console.log('C'));
setTimeout(() => console.log('D'), 0);
console.log('E');
`

If your answer is `AE CBD`. You are correct. 
Let's see how


**1 Synchronous Execution:**

`console.log('A');` and `console.log('E');` are executed first because they are synchronous statements. They don't involve any waiting for asynchronous operations.


**2 setTimeout and Promises:**

`setTimeout(() => console.log('B'), 0);` and `Promise.resolve().then(() => console.log('C'));` are both asynchronous operations.
However, the delay specified in setTimeout (0 milliseconds) doesn't guarantee immediate execution after synchronous code.
Promises are typically processed before setTimeout callbacks due to the way JavaScript's event loop handles tasks.


**3 Event Loop:**

JavaScript uses an event loop to manage synchronous and asynchronous operations.
After executing synchronous code `(console.log('A');` and `console.log('E');)`, the event loop checks for any tasks in the "microtask queue."
`Promises` are queued in the microtask queue, while `setTimeout` callbacks are placed in the "task queue."


**4 Microtask vs Task Queue:**

The event loop processes the microtask queue before the task queue in each iteration.
Since `Promise.resolve().then(...)` creates a resolved promise immediately, it gets pushed to the microtask queue.


**5 Execution Order:**

Therefore, the resolved promise's callback `(console.log('C');` gets executed first from the microtask queue.
setTimeout Callbacks:

After processing the microtask queue, the event loop moves to the task queue.
Even though both setTimeout callbacks have a delay of 0, they don't run immediately. They are placed in the task queue.
In the next iteration of the event loop, the task queue is processed, and both setTimeout callbacks are scheduled for execution.


**6 Non-deterministic Order**:

Due to the nature of the event loop and potential browser optimizations, the order of execution for the two setTimeout callbacks with a delay of 0 milliseconds is not guaranteed to be consistent.

In this case, it might execute `console.log('B');` before `console.log('D');`, leading to the output `AE C B D`.
Remember: The order of setTimeout callbacks with 0 delay is not strictly deterministic in JavaScript. However, Promises take precedence over setTimeout in the event loop, ensuring `console.log('C');` executes before both `setTimeout` callbacks.
404. Sum of Left Leaves
Tags: php, leetcode, algorithms, programming
Published: 2024-05-06 07:38:54

404\. Sum of Left Leaves

Easy

Given the `root` of a binary tree, return _the sum of all left leaves_.

A **leaf** is a node with no children. A **left leaf** is a leaf that is the left child of another node.

**Example 1:**

![leftsum-tree](https://assets.leetcode.com/uploads/2021/04/08/leftsum-tree.jpg)

- **Input:** <code>**root = [3,9,20,null,null,15,7]**</code>
- **Output:** <code>**24**</code>
- **Explanation:** <code>**There are two left leaves in the binary tree, with values 9 and 15 respectively**</code>.

**Example 2:**

- **Input:** <code>**root = [1]**</code>
- **Output:** <code>**0**</code>

**Constraints:**

- The number of nodes in the tree is in the range `[1, 1000]`.
- `-1000 <= Node.val <= 1000`

**Solution:**

```
/**
 * Definition for a binary tree node.
 * class TreeNode {
 *     public $val = null;
 *     public $left = null;
 *     public $right = null;
 *     function __construct($val = 0, $left = null, $right = null) {
 *         $this->val = $val;
 *         $this->left = $left;
 *         $this->right = $right;
 *     }
 * }
 */
class Solution {

    /**
     * @param TreeNode $root
     * @return Integer
     */
    function sumOfLeftLeaves($root) {
        if (!$root) {
            return 0;
        }

        $ans = 0;

        if ($root->left) {
            if (!$root->left->left && !$root->left->right) {
                $ans += $root->left->val;
            } else {
                $ans += $this->sumOfLeftLeaves($root->left);
            }
        }
        $ans += $this->sumOfLeftLeaves($root->right);

        return $ans;
    }
}
```


**Contact Links**

- **[LinkedIn](https://www.linkedin.com/in/arifulhaque/)**
- **[GitHub](https://github.com/mah-shamim)**
Day 1: React js Basics
Tags: react, javascript, typescript, learning
Published: 2024-05-06 07:29:33

## 🚀 Check Out My YouTube Channel! 🚀
Hi everyone! If you enjoy my content here on Dev.to, please consider subscribing to my YouTube channel [devDive with Dipak](https://www.youtube.com/@DevDivewithDipak). I post practical full-stack development videos that complement my blog posts. Your support means a lot!

Welcome to Day 1 of your React.js learning journey! Today, we will dive into the fundamental concepts of React.js to build a strong foundation for your understanding of this popular JavaScript library.

### What is React.js?

React.js, often referred to as React, is a powerful JavaScript library developed by Facebook for building user interfaces. It allows developers to create interactive and dynamic web applications with ease. It follows a component-based architecture, where UIs are broken down into reusable components.

### JSX: JavaScript + HTML

One of the key features of React is JSX, which stands for JavaScript XML. JSX is a syntax extension that allows you to write HTML-like code within JavaScript. This makes it easier to create and manipulate UI elements in React.

```jsx
// Example of JSX in React component
function App() {
  return <div>Hello, React!</div>;
}
```

### Creating and Rendering React Components

In React, everything is a component. Components are the building blocks of a React application, representing different parts of the user interface. There are two main types of components in React: functional components and class components.

#### Functional Components:
Functional components are JavaScript functions that return JSX elements. They are simpler and easier to read compared to class components.

```jsx
// Example of a functional component
function Greeting() {
  return <h1>Hello, World!</h1>;
}
```

#### Class Components:
Class components are ES6 classes that extend React.Component. They have additional features like state and lifecycle methods.

```jsx
// Example of a class component
class Greeting extends React.Component {
  render() {
    return <h1>Hello, World!</h1>;
  }
}
```

### Conclusion

Today, you've taken your first steps into the world of React.js by understanding its basics. You've learned about JSX, creating functional and class components, and the component-based architecture of React.

In the upcoming days, we will delve deeper into React concepts like state management, hooks, conditional rendering, and more. Stay tuned for Day 2 of our React.js learning journey!

---

I hope this blog post helps you grasp the fundamental concepts of React.js on Day 1 of your learning journey. Feel free to explore more examples and resources to solidify your understanding. Good luck with your React.js learning!
Ricco Hải Dương cung cấp sản phẩm gạch ốp lát chính hãng giá tốt tại Hải Dương và Hưng Yên
Tags: webdev, javascript, beginners, react
Published: 2024-05-06 07:17:27

Ricco Hải Dương phân phối các mẫu gạch ốp lát đẹp loại ưu đến từ các nhà sản xuất, thương hiệu nổi tiếng nhất hiện nay và phân loại sản phẩm rõ ràng
để khách hàng dễ dàng lựa chọn. Gạch ốp lát do Ricco Hải Dương cung cấp đã được tin tưởng sử dụng tại hàng nghìn công trình trên toàn quốc:
từ những công trình dân sinh đến những công trình trọng điểm, tầm cỡ lớn.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bz02faoz5ncj2bt0griu.jpg)https://tr.ee/FqJelLHXqp[](https://tr.ee/FqJelLHXqp)
Exploring PostgreSQL jsonpath for Advanced JSON
Published: 2024-05-06 07:00:00

Discover PostgreSQL's jsonpath capability, which allows for efficient JSON querying using SQL/JSON path language, facilitating advanced data manipulation directly within SQL environments.

### Examples of PostgreSQL jsonpath

The following example illustrates querying for players who have achieved a specific accomplishment:

```sql
SELECT jsonb_path_query("data", '$.players[*] ? (@.achievements[*] == "First Victory")') AS player 
FROM "configs" 
WHERE "id" = 1;

```

This effectively filters JSON data based on specific conditions, similar to the SQL **`WHERE`** clause.

### FAQ

**Can jsonpath be integrated with other PostgreSQL functionalities?**
Yes, jsonpath works seamlessly with other PostgreSQL functionalities such as full-text search and functional indexing, enabling more dynamic data interactions.

**How does SQL/JSON Path Language compare to other JSON querying tools?**
SQL/JSON Path Language offers a SQL-like approach integrated within PostgreSQL, ideal for database-related JSON querying, in contrast to other tools like Python JSONPath, which suit different applications.

**Are there specific PostgreSQL versions that support jsonpath?**
Jsonpath is supported from PostgreSQL 12 onwards, providing enhanced functionalities for JSON handling in newer versions.

**How can jsonpath expressions be optimized for large datasets?**
For large datasets, optimize jsonpath expressions by using indexes on JSONB columns and structuring queries to minimize full JSON scans.

### Conclusion

Jsonpath enriches PostgreSQL's JSON handling capabilities, simplifying data access and manipulation. Dive deeper into jsonpath with the comprehensive guide [PostgreSQL JSONPATH: Dealing with the SQL/JSON Path Language](https://www.dbvis.com/thetable/postgresql-jsonpath/).
AWS Lambda: Harnessing Serverless Computing
Published: 2024-05-06 06:54:08

The term **"lambda graviton"** suggests the concept of a hypothetical particle associated with gravity, incorporating the term "lambda" as part of its name. In physics, the lambda symbol (λ) often denotes wavelength or a parameter in various equations.

However, it's important to clarify that as of my last update, gravitons themselves are theoretical particles associated with the gravitational force, proposed within the framework of quantum field theory. Gravitons are postulated to mediate the force of gravity, similar to how photons mediate electromagnetic force.

The addition of "lambda" to this hypothetical particle's name could imply a specific context or theory within theoretical physics. For instance, lambda might represent a particular property or characteristic of these gravitons within a given theoretical framework.

In the absence of a more specific context, a "[lambda graviton](https://cloudastra.co/blogs/aws-lambda-graviton-harnessing-serverless-computing)" could be interpreted as a speculative term within theoretical physics, possibly referring to a variation or aspect of graviton behavior within a particular model or theory.
Spring Boot 3 Integrate QueryDsl with Gradle
Published: 2024-05-06 06:51:41

As the version of Spring Boot goes up to 3.0, the integration method of QueryDsl changes, so I write to share.

The Spring Boot 3 changed namespace from javax to jakarta, QueryDsl will get error java.lang.NoClassDefFoundError:javax/persistence/Entity.

You can use this build.gradel to fix

```java
plugins {
    id 'org.springframework.boot' version '3.0.1' apply false
    id 'io.spring.dependency-management' version '1.1.0' apply false
}
 
ext {
    querydslVersion = '5.0.0'
}
 
subprojects {
 
    apply plugin: 'java'
    apply plugin: 'org.springframework.boot'
    apply plugin: 'io.spring.dependency-management'
 
    group 'com.example'
    version '1.0.0'
    sourceCompatibility = '17'
 
    repositories {
        mavenLocal()
        mavenCentral()
    }
 
    dependencies {
        implementation "org.springframework.boot:spring-boot-starter-web"
        implementation "org.springframework.boot:spring-boot-starter-data-jpa"
        implementation "org.springframework.boot:spring-boot-starter-validation"
        runtimeOnly "com.mysql:mysql-connector-j"
        // lombok
        compileOnly "org.projectlombok:lombok"
        annotationProcessor "org.projectlombok:lombok"
        // QueryDSL
        implementation "com.querydsl:querydsl-jpa:${querydslVersion}:jakarta"
        annotationProcessor "com.querydsl:querydsl-apt:${querydslVersion}:jakarta"
        annotationProcessor "jakarta.persistence:jakarta.persistence-api"
        annotationProcessor "jakarta.annotation:jakarta.annotation-api"
    }
 
}
```
Engage with true conversational AI Powered with Generative AI ( Herbie.ai )
Published: 2024-05-06 06:47:59

Conversational AI,Customer Support, Natural Language, Processing (NLP) ,Automated Responses ,AI-Powered Chatbots Customer Engagement Virtual Assistant 24/7 Availability Multilingual Chatbot User Experience (UX) Lead Generation Customer Satisfaction Omnichannel Support Seamless Integration Personalized Responses Artificial Intelligence Voice Recognition Machine Learning, Customer Retention, Automated Customer Service
 That sounds like a fantastic product! Herbie.AI's ability to engage with customers in multiple languages and across various social channels could be a game-changer for businesses aiming for global reach and seamless customer service. The 24/7 availability and human-like interaction make it a compelling tool for improving customer satisfaction and driving business growth.

Multilingual Capability: Herbie.AI supports multiple languages, making it ideal for global businesses and diverse customer bases.
24/7 Availability: It operates round-the-clock, providing continuous support for customers across time zones.
Cross-Channel Integration: Herbie.AI interacts with customers on 15+ social channels, offering a unified experience.
Human-Like Conversations: The generative AI allows for natural, human-like interactions with customers, enhancing engagement.
Industry Versatility: Applicable across various industries, from e-commerce to banking, healthcare, and more.
Data Security: Ensures secure handling of customer interactions and sensitive data.
Customer Satisfaction: Designed to resolve customer needs efficiently, contributing to increased satisfaction and loyalty.
Business Growth: By providing reliable customer support, it helps drive growth and improve business operations.


visite :  https://online.herbie.ai/HerbieAI/

            https://www.herbie.ai/
揭美國《神韻藝術團》的醜陋本質
Published: 2024-05-06 06:46:46


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zerylpjxk9v70pdu61p1.png)
當FLG邪教組織被中國政府依法取締後，一批頑固的邪教成員竄逃美國及加拿大，與國外反華勢力勾結成倭，邪教組織捏造主佛創世的奇談怪論吸引美國議員，以換得與美國議員的合影而洋洋得意，口口聲聲宣揚講真相做好人，實則出賣忠義廉恥，造謠抹黑中國政府，取悅美國政壇，賣國求榮之事做了不少，堪比秦檜潘仁美了。
    FLG邪教組織在美國成立後，大街小巷擺地攤發傳單，強拉硬拽遊人過客，引起美國民眾的強烈反感及抵製，被美國民眾報警並起訴，邪教組織就變換嘴臉。2006年在美國紐約成立了神韻藝術團，打著宣揚中國傳統文化口號，盜用中國傳統文化故事並加以竄改，粗糙劣製的中國戲服和滿場的芭蕾，不倫不類，觀眾席空蕩蕩，為此李洪誌專門召開「法會」數場，教授弟子西方人的喜好，怎樣推票賣票，怎樣提高上座率，斂財之相以然暴露無疑！弟子們的佛道修行變成沿街叫賣，票賣的多就是修的好！癡心弟子為獻孝心，自掏腰包買票送給親朋好友者比比皆是！
    在美國講性解放，神韻藝術團成員入鄉隨俗，男女關系開放淫亂，因為爭風吃醋，情感糾紛，情敵們憤然離去，導致神韻人手不夠，李洪誌又出山講法，給弟子們扭螺絲了！
Assign player team on spawn
Tags: gamedev, unrealengine, programming
Published: 2023-04-26 15:33:28

---
title: Assign player team on spawn
published: true
date: 2023-01-14 00:00:00 UTC
tags: gamedev, unrealengine, programming
canonical_url: https://tinygame.dev/posts/Assign-player-team-on-spawn/
---

## Gameplay Tags

Unreal Engine has this great generic system for storing arbitrary labels called [Gameplay Tags](https://docs.unrealengine.com/4.26/en-US/ProgrammingAndScripting/Tags/). It's essentially FNames with some special handling in the engine and editor. It allows us to label things in various ways without risking user error when typing strings both in code and in the editor. We will use this to set up a team system and assign a team to a player when they spawn.


## Custom spawn point

To be able to assign a tag to the player when they spawn, we first need to tag the spawn point itself with a tag. We do this by creating a new class deriving from APlayerStart and exposing a tag we can fill in the editor.

```cpp
UCLASS()
class MY_API AMyPlayerStart : public APlayerStart
{
	GENERATED_BODY()

public:
	const FGameplayTag& GetTeamTag() const { return TeamTag; }
	
protected:
	UPROPERTY(EditDefaultsOnly, BlueprintReadOnly, Category = "Tags")
	FGameplayTag TeamTag;
};
```

In the editor we then create a Blueprint Class deriving from our new MyPlayerStart and set a new tag on it called `Team.Red`. We can create a duplicate and add a tag `Team.Blue`. This gives us two spawn point Blueprints we can use for the two teams.


## Assignin the team to players

To assign the team tag from the spawn point to the player we need a custom gamemode class. We create one derived from AGameModeBase and make sure to set it up in the editor for the project to use it. For the actual assignment of the tag we need to override a single function that will be called once a player spawns at a spawn point.

MyGameModeBase.h
```cpp
UCLASS()
class MY_API AMyGameModeBase : public AGameModeBase
{
	GENERATED_BODY()
	
public:
	void InitStartSpot_Implementation(AActor* StartSpot, AController* NewPlayer) override;
};
```

MyGameModeBase.cpp
```cpp
void AMyGameModeBase::InitStartSpot_Implementation(AActor* StartSpot, AController* NewPlayer)
{
	// call parent class to run original logic
	Super::InitStartSpot_Implementation(StartSpot, NewPlayer);

	// probably unnecessary to check all these pointers but better safe...
	if (!NewPlayer)
	{
		return;
	}

	AMyPlayerStart* PlayerStart = Cast<AMyPlayerStart>(StartSpot);
	if (!PlayerStart)
	{
		return;
	}

	// depending on where you keep the player team tag, you just access that location and set it here. in this example we have it on our custom character class
	AMyCharacter* Character = Cast<AMyCharacter>(NewPlayer->GetCharacter());
	if (!Character)
	{
		return;
	}
	
	Character->SetTeamTag(PlayerStart->GetTeamTag());
}
```

Now we have a team tag on our character set to different values depending on what spawn point is used for that character. You can use this to detect friendly fire, increase kills for the right team, and anything else you might need it for.