teleren/devto huggingface dataset:
Appslite- Find Your Favorite APK Games And Apps
Tags: android, gaming, design, ios
Published: 2024-05-06 23:20:34

APPSLITE stands as an exemplary destination for aficionados of free Android games and applications. The platform is distinguished by its extensive assortment of apps, ensuring that every user can find something tailored to their interests and needs. Beyond mere variety, APPSLITE places a significant emphasis on the safety of its offerings. Each application undergoes rigorous screening to ensure it meets stringent security standards, providing users with peace of mind when downloading and using the apps. This focus on safety and ease of use allows users to effortlessly enhance the functionality and features of their Android devices, keeping them up-to-date with the latest technological advancements without compromising security. Thus, APPSLITE is not just a repository of applications but a reliable and enriching hub for maximizing the potential of Android smartphones. [https://appslite.org/](https://appslite.org/)






Is this conversation helpful so far?
Playing with DragonRuby Game Toolkit (DRGTK)
Tags: gamedev, dragonruby, ruby
Published: 2024-05-06 23:20:30

Last week I was working on a very simple game to test [DragonRuby](https://dragonruby.org/toolkit/game) Game Toolkit and learn its API.

This Ruby implementation is based on [mruby](https://mruby.org/) and [LLVM](https://llvm.org/) and it’s commercial software but cheap.

The game toolkit has a simple API to handle sprites with animations, sound/music, inputs, basic drawing primitives like lines or rectangles, allows for HTTP requests  and other niceties. It also has a fixed resolution and 60 times a second game loop.

The engine has a game loop that calls to a **#tick** method where you draw, check inputs and update game logic.

The code is structured in a couple of classes, the main one is the MyGame, that contains other classes like the Player, the list of FloorFires and the Coin to collect.

When it detects a collision it plays a sound. The game is paused when the window loses focus.

For collision detection, it uses some builtin rectangle intersection primitives.

For Input handling, the keyboard, arrows/WASD are handled the same.

And that’s pretty much it. There are a lot to improve the game but I think I’ll start a new project with a better idea to start doing something funnier and more polished.

Besides [the official docs](https://docs.dragonruby.org/static/docs.html), I learnt a lot from [this post series](https://dev.to/presidentbeef/series/16166), kudos to Justin!, and also the [official discord](https://discord.com/channels/608064116111966245/) is super friendly and helpful when you get stuck on something.

#### The start screen:

![start screen](https://i.ibb.co/hs791w4/clideo-editor-3c8662f134954b7885542cdacc289741.gif)

#### In-game:

![in-game animation](https://i.ibb.co/XjCPhQ5/clideo-editor-4a7788b1097a4da2a8b419cc1fa6f7fa.gif)

The source is about 360 lines and available [on GitHub](https://github.com/megatux/dragonruby_the_fire/). The assets are free.

You can download or play it online [here](https://megatux.itch.io/the-fire) at Itch.io (DRGTK includes a great tool to deploy to Itch.io)

Happy hacking!
Starting a Side Hustle/Side Project in 2024.
Tags: sideprojects, webdev, beginners, programming
Published: 2024-05-06 22:42:19

## This was taken from Medium when I wrote this post originally

This will be my “first” post on “my” blog. I actually wrote something up and went to publish it, but for some reason, it did not save, and I lost my progress. I was going to say, “F*** it,” but I decided to get it done.

I discussed how I misspent my youth from my late teens to early twenties, finally turned my life around, and, by some miracle, got into IT at 27 years old. At 31, I am an IT Support Engineer with almost five years of experience and multiple IT certifications. I am on the way to getting my B.S. in Information Technology after starting my school journey in 2010.

In my daily work, I use Office 365/Azure for email and Identity Access Management, Intune for MDM/MAM, AWS for EC2 and Workspace administration, PowerShell for system administration, and the list could go on—and I love every second of it.

Now, I have a side project/side hustle because I want to learn more. I want to learn software development, web development, marketing, business, accounting, blogging, and entrepreneurship—again, the list could go on.


![Landing Page of NYCITSupport.com which rotates using Unsplash featured images.](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/5774igje0wqnobnga9ge.PNG)

**Now, what is this project going to be: [NYCITSupport.com](https://nycitsupport.com/)**

I like to always have these grand plans and schemes in my head, so what do I want [NYCITSupport.com](https://nycitsupport.com/) to be? I want it to be the go-to spot for NYC IT Support, IT Education and Training, Local IT Job listings in NYC, an IT Networking platform, etc. I know it's broad, but that makes this fun. So far, the coming soon has been built and will need to be redone, but it's a start.

## Stack

The landing page was built using HTML/CSS and some Javascript. How have I been learning this? A mix of AI ([Claude](https://claude.ai/), [ChatGPT](https://chatgpt.com/)) and learning how to create a site by going through the foundational section of [The Odin Project](https://www.theodinproject.com/). I will also continue to go through this course and the React portion. 

We are using [Click Up](https://clickup.com/) for Project Management, [Hostinger](https://www.hostinger.com/) to host the site currently, [ProfitBooks](https://www.profitbookshq.com/) for the bookkeeping/accounting, Office suite for Word, Excel.

_Since I have originally posted this article, I have finally started the JS portion of the TOP._

For now, that is all. I will continue to check in, and hopefully, in a year, I can look back and see the hundreds of articles I have written and how far I have come.

It is overwhelming but at the same time I am excited to keep learning more and more.
Few new things in Python which I learned last week.
Tags: python, machinelearning, dataengineering
Published: 2024-05-06 22:03:56

**Chunkify Huge List into Smaller N equal size lists.**

In order to backfill data for one of our machine learning pipeline I have to divide the date list into small n list of equal length and distribute them at n GPU cluster.    

``` Python
from datetime import timedelta,date,datetime
start_dt = date(2023,1,1)
end_dt = date(2023,12,31)
cdays = []

while start_dt < end_dt:
    cdays.append(start_dt)
    start_dt += timedelta(days=3)
    
#print(cdays)

def split(a, n):
    k, m = divmod(len(a), n)
    return (a[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n))

split_list = list(split(cdays, 15))
print(split_list[0])

#Output
[datetime.date(2023, 1, 1), datetime.date(2023, 1, 4), datetime.date(2023, 1, 7), datetime.date(2023, 1, 10), datetime.date(2023, 1, 13), datetime.date(2023, 1, 16), datetime.date(2023, 1, 19), datetime.date(2023, 1, 22), datetime.date(2023, 1, 25)]

```


**\_\_all\_\_ in Python**

The <mark> \_\_all\_\_ </mark> represents name of variable ,function or module that you want to  expose to wildcards import. This method really comes handy when large number of function in your base module and you just want to export only few of them. Example let's say you have.

```Python

#foo.py

waz = 3
bar = 9

def baz():
    return 'baz'

__all__ = ['bar','baz']

```

and now bar.py imports from foo.py 

```Python
#bar.py

from foo import *

print(bar)

print(baz)

print(waz) # This will trigger the exception , as waz was is not exported by the module.

```

**Conclusion**

Hope this was easy and clear to understand.



***Some Final Words***
_If this blog was helpful and you wish to show a little support, you could:_

1. 👍 300 times for this story
2. Follow me on LinkedIn: https://www.linkedin.com/in/raju-n-203b2115/

These actions really really really help me out, and are much appreciated!
Our game progress ~ Mirror Movement ~
Published: 2024-05-06 21:56:26

## Introduction 

In the previous posts, I introduced the basic concept of the game and implemented the login screen. From this article onwards, I will introduce the implementation of the main part of the game. We will cover the following topics, each of which is currently under active development.

- ~~User Animation and Items~~
- ~~Timer~~
- ~~Basic Rules ( Victory, Defeat )~~
- ~~Mirror~~
- Mirror Movement ( Through, Break, Trap )

This post will shows the implementation of Mirror mechanism.

## Summary of the implementation of Mirror mechanism

At this time, mirrors can be choke points, offering players strategic options to enhance the game's enjoyment. Players can use mirrors to move to another worlds, destroy mirrors, and set traps. In this implementation, we've added functions for moving and destroying mirrors.

## Moving via Mirrors

Players can use mirrors to move to another world. To keep the implementation simple, we've prepared two same levels, and using a mirror changes the player's position accordingly. To indicate the transition to the user, we adjust the lighting to represent the mirror world.

### Code Example

```
[PunRPC]
public void MoveAnotherWorld(float distance)
{
  Vector3 currentPosition = transform.position;
  // Z direction -83.4
  currentPosition.z += distance;
  // move
  transform.position = currentPosition;
}    
```

Here's the video of moving via mirrors.

{% youtube https://www.youtube.com/watch?v=m7TjDH3al-0 %}

## Breaking Mirrors
The Survivor has the ability to destroy mirrors, rendering them unusable and preventing Hunters from passing through.

The implementation is relatively easy : when using the gun, it casts a ray to detect collisions. If the hit object is a mirror and it's usable, the destruction process is executed.

### Code Example

```
Ray ray = cam.ViewportPointToRay(new Vector2(0.5f, 0.5f));

if(Physics.Raycast(ray, out RaycastHit hit))
{
  if(hit.collider.gameObject.tag == "Mirror")
  {
    Mirror mirror = hit.collider.gameObject.GetComponent<Mirror>();
    if (mirror != null)
    {
         mirror.Break();
         mirror.DisableMirror();
     }
   }
}
```

Here's the video of breaking mirrors.

{% youtube https://www.youtube.com/watch?v=GeMqSpN-ND4 %}

## Conclusion
This time, We could not implement the trap function, so I'd like to try it in next time.

- ~~User Animation and Items~~
- ~~Timer~~
- ~~Basic Rules ( Victory, Defeat )~~
- ~~Mirror~~
- ~~Mirror Movement ( Through, Break, Trap )~~
Github Trick
Published: 2024-05-06 21:56:12



To open project in vscode from github instead of clone repository in to see or edit project we can do it directly😉

## 
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/ept4ai8owtpk5ht428nt.jpg)How?
By adding "vscode.dev/" in the link before github word.

 Another thing I really like we can open working tree window to see changes🔥
🗺️ Neo4J #GraphSummits as data!
Tags: duckdb, datascience, database, jupyter
Published: 2024-05-06 21:55:41

## 💡 Inception

{% twitter 1761440186745962987 %}

Then I wanted to get all the events from a data perspective... and eventually put them on a map like this one: 

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

## 🎯 About

The purpose of this post is to show:

- 🧰 **How** I did it
- 💡 **The opportunities** it opens for anyone to build anything on top of these data.

## 🍿 Demo

{% youtube 4hJxggHg-8U %}

## 🔖 Refs

- [🗓️ Neo4J GraphSummit events](https://www.kaggle.com/datasets/adriensales/neo4j-graphsummit)
- [🌐 Neo4J GraphSummit for dummies](https://www.kaggle.com/code/adriensales/neo4j-graphsummit-for-dummies)
A Comprehensive Guide to Queue Data Structure
Tags: datastructures, queue
Published: 2024-05-06 21:39:55

A queue is a data structure that allows the addition and removal of elements with a specific rule: the first element to be added is the first one to be removed. This rule follows the FIFO (First-In, First-Out) order, which means that the first item to enter the queue is also the first to leave. Queues are similar to a real-life queue of people, where the person who arrives first is the one to be served first.

Now, let's look at a Java code example that represents a simple implementation of a queue:

```java
public class Queue {
    private int size;
    private double[] data;
    private int head;
    private int tail;
    private int length;

    private boolean isEmpty() {
        return this.length == 0;
    }

    private boolean isFull() {
        return this.tail == this.size - 1;
    }

    public Queue(int size) {
        this.size = size;
        this.data = new double[size];
        this.head = 0;
        this.tail = -1;
        this.length = 0;
    }

    public void enqueue(double value) {
        if (this.isFull()) {
            throw new RuntimeException("queue overflow");
        }

        this.tail++;
        this.data[this.tail] = value;
        this.length++;
    }

    public void dequeue() {
        if (this.isEmpty()) {
           throw new RuntimeException("empty queue"); 
        }

        this.head++;
        this.length--;
    }
}
```
In the code above we have a simple queue structure with 5 properties:

- `size`: The queue size
- `data`: An array of double that will store the queue data
- `head`: The position of the first element of the queue
- `tail`: The position of the last element of the queue
- `length`: The queue length

And we have 2 main methods:
- `enqueue`: This method verifies if the queue is full if it's true an exception will be thrown saying the queue is full, if it's false now the tail position will be the next, and we will store the data in that position and increment the length
- `dequeue`:  This method verifies if the queue is empty if it's true an exception will be thrown saying the queue is empty, if it's false now the head of the queue is the next position and the length is decreased.

Note that we didn't really remove the element of the queue just changed the head and tail positions.

`enqueue` Usage example:

```java
Queue queue = new Queue(3);
queue.enqueue(10); // index 0
queue.enqueue(20); // index 1
queue.enqueue(30); // index 2
// head is 0 and tail is 2
```

`dequeue` Usage example:

```java
Queue queue = new Queue(3);
queue.enqueue(10); // index 0
queue.enqueue(20); // index 1
queue.enqueue(30); // index 2
// head is 0 and tail is 2
queue.dequeue();
// after dequeue head is 1 and tail is 2
```
Introduction to DOM
Tags: webdev, javascript, programming, beginners
Published: 2024-05-06 21:28:03

**What is DOM & its elements in JavaScript?**

Have you ever wondered how web pages are able to dynamically update content without having to reload the entire page? Or how JavaScript interacts with HTML and CSS to bring websites to life? The answer lies in a fundamental concept called the Document Object Model, or DOM for short.

DOM or Document Object Model is an API (Application programming interface) that defines a logical layout of content & how it’s accessed and manipulated. Using DOM, programmers can build, construct, add, modify, delete, or navigate elements or contents. Everything present on an HTML webpage can be edited using DOM.

DOM is not a programming language but just a way to access/modify data. Without DOM, JavaScript won’t have any model, layout of webpages, XML, or HTML documents. Magical right? Let me fill you in on how DOM works

**How Does DOM Works?**

When a web page is loaded in a browser, the browser creates a DOM representation of the page based on the HTML markup. This DOM tree consists of nodes, where each node corresponds to an HTML element, such as div tag, p tag, img tag, etc. These nodes are organized in a hierarchical manner, with the html element at the root of the tree. Great right? Let's look at the flowchart I got online to under better.
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9i8qld6s9orvt4atoae4.jpg) 

**Structure of DOM**

I am going to be using visuals for better understanding of DOM structure. The structure represent a tree like way of explaining what DOM is all about using various tags and elements. I hope this will help in getting more understanding about DOM.

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

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

The images above explain an hierarchy kind of structure when dealing with DOM. I got the images online as well.

**Properties of DOM**

Some common properties include:

**innerHTML**: Gets or sets the HTML content of a node.
**textContent**: Gets or sets the text content of a node and its descendants.
**style**: Allows access to CSS properties of an element for dynamic styling.
**classList**: Allows manipulation of the classes applied to an element.
**parentNode**: References the parent node of a given node.


**Conclusion**
DOM & JavaScript work hand –in-hand to form a perfect webpage. DOM uses hierarchical structure such as tree structure to meet up the requirements.
DOM is a powerful tool that allows developers to interact with and manipulate web pages dynamically. 
There's a whole lot to learn and I'm still learning more about DOM. If you are still lost, YouTube is your friend.
Document Object Model
Tags: webdev, javascript, programming, frontend
Published: 2024-05-06 20:54:01

As a beginner, learning html, css and javascript you must at a point ask yourself question like, cant i build a website without javascript or say whats is javascript doing that i cant ignore? 

Yes, there is a place for each it, html to add content, CSS to style and Javascript for functionality or interactive and some call it behaviour.
For example, When your alarm wakes you 5am, you either off it or snooze it uisng the button, so think of all the content you see (html), then how the alarm is designed(CSS) i.e interface then when you press the button to left or right and something happened(Javascript). 


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



Another question you will likely asked is how does this behaviour happen? It's simple, javascript accessing the content in HTML by communicating with the browser using the properties, methods, and events in the interface called the Document Object Model, or DOM, it ia a tree-like representation of the web page that gets loaded into the browser.

So here is how DOM works by targeting the content through the element and giving it some instructions to carry out, lets look at DOM structure. 

**DOM structure**
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p6qnx4lcqiwk3jhnzumm.png)
lets say I want to control the `tr` from javascript using DOM, to access it I go like,

```
const userTable = document.getElementsByTagName("tr");
```
and you ahead to give instruction or use it for whatever you want to, which lead us to DOM Properties and method. 

DOM make use of properties and method to access object(HTML Elment), Let mention few DOM Methods, Property and how they used.

[DOM METHODs](https://developer.mozilla.org/en-US/docs/Web/API/Document_Object_Model/Traversing_an_HTML_table_with_JavaScript_and_DOM_Interfaces) 

*[addEventListener()](https://www.w3schools.com/jsref/met_element_addeventlistener.asp)
*```
element.addEventListener("click", myFunction);

function myFunction() {
  document.getElementById("demo").innerHTML = "Hello World";
}
```
[appendChild()](https://www.w3schools.com/jsref/met_node_appendchild.asp)
```
const node = document.createElement("li");
const textnode = document.createTextNode("Water");
node.appendChild(textnode);
document.getElementById("myList").appendChild(node);
```
DOM Properties
Dev Rooms: Collaborative Coding Platform
Tags: webdev, nextjs, postgres, opensource
Published: 2024-05-06 20:50:12

Are you tired of coding alone? Do you often find yourself wishing for a platform where you can collaborate with fellow developers in real-time? Look no further! Introducing **Dev Rooms** – the ultimate solution for peer coding, group coding, and seamless collaboration.
[**Dev Rooms** GitHub repository](https://github.com/soham-basak/dev-rooms)

## What is Dev Rooms?

**Dev Rooms** is a revolutionary web application built to facilitate collaborative coding experiences. With a powerful stack comprising Next.js, Tailwind CSS, Shadcn, Drizzle ORM, Docker, PostgreSQL, and more, **Dev Rooms** offers a robust and feature-rich platform for developers to come together and code as a team.

## Key Features:

- **Room Creation:** Users can easily create their coding rooms, where they can invite others to join them in real-time coding sessions.
  
- **Join Existing Rooms:** Developers can explore and join existing rooms created by other users, making it effortless to find like-minded collaborators.
  
- **Real-Time Collaboration:** **Dev Rooms** enables seamless real-time collaboration, allowing multiple users to code together, edit files, and communicate effortlessly.
  
- **Peer Reviews:** Users can request peer reviews within their rooms, providing valuable feedback and insights to improve their code quality.
  
- **Powerful Stack:** Leveraging the latest technologies such as Next.js, Tailwind CSS, Shadcn, Drizzle ORM, Docker, and PostgreSQL, **Dev Rooms** ensures a smooth and efficient coding experience.

## Collaboration:

**Dev Rooms** is an open-source project, and we welcome contributions from developers worldwide. Whether you're interested in adding new features, fixing bugs, or improving documentation, there's a place for you in our community. Join us in shaping the future of collaborative coding!

## How Does It Work?

1. **Sign Up:** Get started by signing up for a **Dev Rooms** account.
  
2. **Create or Join a Room:** Create your own coding room or explore existing rooms to join.
  
3. **Code Together:** Collaborate with fellow developers in real-time, sharing ideas, solving problems, and building amazing projects together.
  
4. **Peer Review:** Seek feedback from your peers to enhance your coding skills and improve your projects.

## Get Started with Dev Rooms Today!

Ready to experience the power of collaborative coding? Head over to the [**Dev Rooms** GitHub repository](https://github.com/soham-basak/dev-rooms) to access the codebase and start building your own collaborative coding platform.

Join the **Dev Rooms** community and revolutionize the way you code – together!
U Zaw Win Swe: Illuminating Truths Through Journalism
Published: 2024-05-06 20:19:39

From the bustling streets to the corridors of power, U Zaw Win Swe's journalistic journey is marked by a relentless pursuit of truth and a steadfast [commitment ](https://southeastasiaglobe.com/the-mandalay-spirit/)to amplifying the voices of the marginalized. With a keen eye for detail and a knack for capturing the essence of every story, U Zaw Win Swe navigates the complexities of his environment with nuance and empathy, offering readers a window into the heart of the issues that shape our world.
In an era where information is abundant yet [truth ](https://www.mdn.gov.mm/en/president-honours-myanmars-biggest-taxpayers-2018-2019-tax-year)often elusive, U Zaw Win Swe's work serves as a beacon of integrity and clarity. Through U Zaw Win Swe writings, he not only informs but also inspires, challenging readers to confront the realities of our time and envision a better future.
As a journalist, Zaw Win Swe embodies the timeless values of integrity, courage, and empathy, reminding us of the profound impact that storytelling can have in shaping our understanding of the world and our place within it. In the ever-evolving landscape of journalism, Zaw Win Swe voice stands as a testament to the power of words to ignite change and illuminate the path forward.