teleren/devto huggingface dataset:
Mmoexp Path of exile currency: Everything from your skills to your endgame experience
Tags: webdev, javascript, beginners, programming
Published: 2024-05-27 00:46:36

8 Remnant: From The Ashes Release year: 2019 Platforms: Windows, PlayStation 4 and Xbox One, PlayStation 5, Xbox Series X|S
Featuring some of <a href="https://www.mmoexp.com/Path-of-exile/Currency.html">Path of exile currency</a> the most unique monster designs, Remnant: From The Ashes tells the tale of a realm descending into chaos thanks to an alternate dimension evil. The remnants of humanity team up to fight off the monstrous hoard and take back their world.

RELATED: Things We Wish We Knew Before Starting Remnant: From The Ashes

It's a pretty common setup, but Remnant executes itself with such panache and style. If you're looking for a co-op Soulslike game with action, guns, and, most importantly, loot, Remant: From the Ashes is the one to play.

.hidden-poll {display: none} The Ultimate Beginner's Guide To Path Of Exile Path Of Exile: A Comprehensive Beginner's Guide By Charles Burgar Updated Apr 23, 2023
From currency to leveling, this guide will cover all of the essentials a new player needs to survive on Wraeclast.

Quick LinksCreating A Character Finding A Build Surviving The First Few Acts The Passive Tree And Ascendancies Skill Gems And Support Gems Explained How To Upgrade Your Gear Useful Community Resources
No ARPG on the market can match the sheer depth of Path of Exile. This free-to-play dungeon crawler offers a degree of customization that would make other games blush. Everything from your skills to your endgame experience can be suited to <a href="https://www.mmoexp.com/Path-of-exile/Currency.html">cheap POE currency</a> your needs.
10 Key Data Structures We Use Every Day
Tags: data, learning, datastructure
Published: 2024-05-27 00:13:55

Data structures are like the building blocks for organizing information in our daily lives. While they might not be explicitly called out, these structures underlie many of the things we do. Here are 10 key data structures we use every day:

1. **Lists:** These are ordered collections of items, like a grocery list, a to-do list, or the songs in your music playlist. You can easily add, remove, or rearrange items on a list.

2. **Arrays:** Similar to lists, arrays hold a fixed number of items in a specific order. Imagine the buttons on a calculator or the channels on your TV – you access them by their position in the sequence.

3. **Stacks:** These follow a "Last In, First Out" (LIFO) principle. Think of a stack of plates – you can only add or remove plates from the top. This structure is used in things like browser history (you visit the most recently accessed page first) or when undoing actions on a computer program.

4. **Queues:** Unlike stacks, queues operate on a "First In, First Out" (FIFO) basis. Imagine a line at a coffee shop – the person who has been waiting the longest gets served first. Queues are used in waiting lists, task scheduling, and even traffic flow management (vehicles that enter the queue first exit first).

5. **Trees:** Hierarchical structures that mimic real-world trees. Imagine a family tree or an organizational chart. They represent relationships between items, with a root element at the top and branches (sub-elements) connecting to it.

6. **Graphs:** These represent connections between objects. Think of a social media network where users are connected to their friends, or a map where cities are connected by roads. Graphs help us visualize and analyze relationships between different entities.

7. **Hashes:** Used for fast retrieval of information. Imagine a phonebook – you look up a name (key) to find the corresponding phone number (value). Hash tables store data with unique keys for efficient access.

8. **Sets:** Collections of unique items, like the unique words in a document or the different types of fruits in a fruit basket. Sets ensure no duplicates exist within the collection.

9. **Associative Arrays (Dictionaries):** Similar to hash tables, these store key-value pairs but allow for more complex data types as values. Imagine a recipe book where the recipe name (key) is associated with a list of ingredients and instructions (value).

10. **Linked Lists:** These are linear data structures where elements (nodes) are not stored contiguously in memory. Each node holds data and a reference (link) to the next node in the sequence. They are useful for dynamic data (frequently changing size) like managing musical playlists or social media feeds.

Understanding these underlying data structures allows us to better appreciate the organization that underpins seemingly simple aspects of our daily lives. 

Which data structure do you find most surprising in everyday use? Why? or Have you encountered any data structures in your hobbies or work that aren't on this list? Share your experiences!
Javascript Memory Management
Tags: javascript, programming, webdev
Published: 2024-05-26 22:07:42

When the javascript engine starts executing the code it will store variables inside of the memory. for storing data, runtime uses two different memory:
- Stack memory
- Heap memory

> Javascript only can communicate with stack memory.

Before explaining the differences around these memories I should explain the data types in javascript. In javascript, we have two different data types:
 - Primitive types: primitive types stored directly in the stack
      -  String, Number, Boolean, Null, Undefined, Symbol, BigInt

---
      
- Reference types: Stored in the heap and accessed by reference from Stack
     -  Arrays, Functions, Objects


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

---
For maximum optimization in the memory space javascript engine uses something called garbage collector. it will clean the value immediately when a value is not reachable via a variable(label).
My Pen on CodePen
Tags: codepen
Published: 2024-05-26 23:14:36


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

1. 57~~~~
)
Check out this Pen I made!

{% codepen https://codepen.io/Othmane-Belalami/pen/dyEpLYz %}
Online Journal
Tags: devchallenge, awschallenge, amplify, fullstack
Published: 2024-05-26 22:27:13

## What I Built

I built a journaling app that allows users to create, read, update, and delete (CRUD) their journal entries. Users can also filter entries based on the date selected from a calendar component.

## Demo and Code

Live Demo: https://main.d16q40xevlck1a.amplifyapp.com/
Code Repository: https://github.com/skarthikeyan96/amplify-journal/tree/main

## Screenshots:

**Customised auth form**

![Auth](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/zh2jgjz00abehacz2kvj.png)


**Filter entry by date**

![Filter journal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/64jfcw896qdg79g2lfr2.png)

**Creating Journal Entry**

![Create Journal](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pa2bcktbjnd9r0vzcvqw.png)

**Home page**

![Home page](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/0v96209vu5wax1knhipw.png)



## Integrations

**Data Persistence**: Amplify DataStore is used to securely store and retrieve journal entries.
Optional:

**User Authentication**: Amplify Auth for user login and data privacy.

## Features

 -  Create journal
 -  Delete journal
 -  Update journal
 -  Search journal by date
 -  Authentication using Amplify Auth

## Upcoming 

-  Multimedia file support using S3
-  Notification to update the journal entries
Happy Birthday Me, Happy Birthday NeoHaskell
Tags: programming, opensource, haskell
Published: 2024-05-26 22:09:00

---
title: Happy Birthday Me, Happy Birthday NeoHaskell
published: true
description: Unleashing NeoHaskell v0.1.0
tags: #programming #opensource #haskell
cover_image: https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j1oif9h3k8i70m1rpmfw.png
# Use a ratio of 100:42 for best results.
published_at: 2024-05-26 22:09 +0000
---

![a cyberpunk half-man-half-machine being is looking with a grin at a cake, a sign of a neon happy birthday is behind him](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/j1oif9h3k8i70m1rpmfw.png)

Today is a special day for me—it's my birthday and also the release of the first version of NeoHaskell! 🎉 It's exciting to see it being born into the aethereal currents of the internet 30 years after my own birth.

On a personal note, I'm feeling much better since [my last post](https://dev.to/neohaskell/coming-out-as-an-eldritch-god-1nha). I've been focusing on my well-being, remodeling my apartment, and really listening to what my body needs. This reboot of NeoHaskell aligns perfectly with my renewed energy and excitement for ongoing development.

### First Version Highlights

This first version comes with a forked version of `nri-prelude`, an excellent library by NoRedInk, designed with Elm's philosophy in mind and mimicking the Elm core libraries. NeoHaskell takes this as an inspiring starting point to build upon, providing a solid foundation for future development.

### What's Inside the Core Library

- **Accumulator:** A DSL to gather values into an accumulable type.
- **Array:** Fast immutable arrays.
- **Basics:** Fundamental operations and types.
- **Char:** Character operations with ASCII and Unicode support.
- **Console and File:** Basic IO operations.
- **LinkedList:** Comprehensive list operations.
- **Map:** Builder API for maps.
- **Maybe:** Handling optional values.
- **Text:** Text operations including substring handling and formatting.
- **Traits:** Traits for appendable, default, mappable, and thenable types.

These changes aim to create a well-structured and documented codebase, making it easier for others to contribute and ensuring the project’s scalability.

### Getting Started

There aren't any detailed guides or tutorials yet, but you can clone the repository at [NeoHaskell Starter](https://github.com/neohaskell/neohaskell-starter) to start playing with the new version. For any help or instructions, join us on [Discord](https://discord.com/invite/wDj3UYzec8) where the community is ready to support you.

Thanks for being a part of this journey. Let's make great things happen with NeoHaskell!
𝗧𝗵𝗲 𝗙𝗶𝗿𝘀𝘁 𝗦𝘁𝗿𝗲𝗮𝗸 𝗼𝗻 𝗟𝗲𝗲𝘁𝗖𝗼𝗱𝗲
Tags: java, streak, leetcode, dynamicprogramming
Published: 2024-05-26 21:46:43

**Dynamic Programming- Q 552. Student Attendance Record II**
```
class Solution {
    public int checkRecord(int n) {
        final int MOD = 1000000007;
        int[][] dpCurrState = new int[2][3];
        int[][] dpNextState = new int[2][3];
        dpCurrState[0][0] = 1;
        for (int len = 0; len < n; len++) {
            for (int i = 0; i < 2; i++) {
                Arrays.fill(dpNextState[i], 0);
            }
            for (int totalAbsences = 0; totalAbsences < 2; totalAbsences++) {
                for (int consecutiveLates = 0; consecutiveLates < 3; consecutiveLates++) {
                    dpNextState[totalAbsences][0] = (dpNextState[totalAbsences][0] + dpCurrState[totalAbsences][consecutiveLates]) % MOD;
                    if (totalAbsences < 1) {
                        dpNextState[totalAbsences + 1][0] = (dpNextState[totalAbsences + 1][0] + dpCurrState[totalAbsences][consecutiveLates]) % MOD;
                    }       
                    if (consecutiveLates < 2) {
                        dpNextState[totalAbsences][consecutiveLates + 1] = (dpNextState[totalAbsences][consecutiveLates + 1] + dpCurrState[totalAbsences][consecutiveLates]) % MOD;
                    }
                }
            }   
            for (int i = 0; i < 2; i++) {
                System.arraycopy(dpNextState[i], 0, dpCurrState[i], 0, 3);
            }
        }
        int totalCount = 0;
        for (int totalAbsences = 0; totalAbsences < 2; totalAbsences++) {
            for (int consecutiveLates = 0; consecutiveLates < 3; consecutiveLates++) {
                totalCount = (totalCount + dpCurrState[totalAbsences][consecutiveLates]) % MOD;
            }
        }       
        return totalCount;
    }
}
```
𝗢𝗽𝗲𝗻 𝘁𝗼 𝗨𝗽𝗱𝗮𝘁𝗲𝘀 𝗮𝗻𝗱 𝗦𝘂𝗴𝗴𝗲𝘀𝘁𝗶𝗼𝗻𝘀.
𝗔𝗿𝗿𝗮𝘆- 𝗤𝟲 𝗠𝗮𝘅𝗶𝗺𝘂𝗺 𝗦𝗰𝗼𝗿𝗲 𝗪𝗼𝗿𝗱𝘀 𝗙𝗼𝗿𝗺𝗲𝗱 𝗯𝘆 𝗟𝗲𝘁𝘁𝗲𝗿𝘀
Tags: java
Published: 2024-05-26 21:17:12

```
class Solution {
    public int maxScoreWords(String[] words, char[] letters, int[] score) {
        int[] available = new int[26];
        for (char c : letters) {
            available[c - 'a']++;
        }
        int n = words.length;
        int[] wordScores = new int[n];
        int[][] wordCounts = new int[n][26];
        for (int i = 0; i < n; i++) {
            int wordScore = 0;
            for (char ch : words[i].toCharArray()) {
                wordCounts[i][ch - 'a']++;
                wordScore += score[ch - 'a'];
            }
            wordScores[i] = wordScore;
        }
        int maxScore = 0;
        for (int mask = 0; mask < (1 << n); mask++) {
            int[] totalAvailable = available.clone();
            int currentScore = 0;
            boolean valid = true;
            for (int i = 0; i < n; i++) {
                if ((mask & (1 << i)) != 0) {
                    for (int j = 0; j < 26; j++) {
                        totalAvailable[j] -= wordCounts[i][j];
                        currentScore += wordCounts[i][j] * score[j];
                    }
                }
            }
            for (int count : totalAvailable) {
                if (count < 0) {
                    valid = false;
                    break;
                }
            }
            if (valid) {
                maxScore = Math.max(maxScore, currentScore);
            }
        }
        return maxScore;
    }
}
```
𝗢𝗽𝗲𝗻 𝘁𝗼 𝗨𝗽𝗱𝗮𝘁𝗲𝘀 𝗮𝗻𝗱 𝗦𝘂𝗴𝗴𝗲𝘀𝘁𝗶𝗼𝗻𝘀.
Why you should be using Supabase.
Published: 2024-05-26 21:16:43

## Introduction
This article will provide a brief overview of what is Supabase and its powerful features. Supabase is a Free Open Source Software(FOSS) providing a complete backend for mobile and web applications. The biggest challenge when building an app is not the coding, but picking the right tech stack such that the application can function at a huge scale. That's where Supabase comes in providing Database services as an alternative to Firebase. But wait, maybe we're getting ahead of ourselves so first let's understand what we mean by a database.


## What's a database
A database is generally defined as the collection of structured information, or data, stored electronically in a computer system. Nowadays when there are thousands and millions of users running a single application, the need to store data efficiently arises. Here comes the various databases such as Firebase, and Oracle Database which provide methods to store data for modern applications with huge userbases. Supabse being one of them, offers a substitute for Firebase, providing various features such as Database webhooks and authentication services while being cross-platform.


## Let's discuss the infrastructure of Supabase 
Supabase uses Postgres to store data, this is a deliberate decision from the Supabase team. While Postgres does seem like a difficult database as compared to NoSql, Supabases tries to make it simpler and easy to use. 
Below is a diagram of the basic infrastructure of Supabase


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

Now, lets  try to understand each of the above concepts - 
Supabase
The main part. It is the entire backend around the Postgres database.

Supabase Studio
The administration UI, which you see when you go to app.supabase.com.

Supabase Client Libraries
Supabase provides low-level access to Supabase with client libraries in various technologies.

Supabase CLI
Supabase CLI provides a command line interface for the Supabase API.

S3 storage provider
Supabase uses Amazon S3 storage to save all large files. However, for the self-hosted variant, you must select an S3-compatible storage provider.

Didn't quite catch on? No worries, let's simplify the working of Supabse.
At a high level, Supabse provides two things, The backend and The frontend. The backend consists of infrastructure such as a Database, file storage, and edge functions. The front end consists of SDK which basically connects the infrastructure to the various frameworks used to develop applications such as Reacr, flutter, etc. For users this allows the user to simply communicate to the infrastructure and automatically generates REST and GraphQl APIs

## Conclsion 
Supabase is a great open source alternative for Firebase, as most of the services Supabase uses are generally also open source, while also providing the various important services Authentication and row-level-security.
Extension in Docker compose
Tags: docker, python, postgres, kong
Published: 2024-05-26 21:14:08

To write an extension in a **compose.yml** file for Docker, you can use the **x-** prefix to define reusable fragments of configuration. Here's an example demonstrating how to use extensions in compose.yml:

- Define the Extension: Use the **x- **prefix to define reusable configurations.
- Reference the Extension: Use **<<** to include the extension in your service definitions.

## Example compose.yml with Extensions

```
version: '3.8'

# Define extensions
x-common-environment: &common-environment
  environment:
    - NODE_ENV=production
    - LOG_LEVEL=info

x-common-volumes: &common-volumes
  volumes:
    - data:/data

services:
  web:
    image: my-web-app:latest
    <<: *common-environment  # Include common environment variables
    <<: *common-volumes      # Include common volumes
    ports:
      - "80:80"

  worker:
    image: my-worker-app:latest
    <<: *common-environment  # Include common environment variables
    <<: *common-volumes      # Include common volumes
    environment:
      - WORKER_TYPE=background

volumes:
  data:

```

## Key Points:

- Extensions with x- Prefix: Define common configurations with x- prefix.
- Reference Extensions: Use <<: *extension-name to include them in services.
- Reuse Configurations: Simplifies and DRYs up the compose.yml.

This method helps maintain a clean and maintainable compose.yml file by avoiding repetition.
Javascript Engine
Tags: javascript, webdev, programming
Published: 2024-05-26 21:08:52

JavaScript is not directly understood by computers but the browsers have an inbuilt JavaScript engine which helps to convert our JavaScript program into computer-understandable language. So whenever someone talks about running code they are talking about a javascript engine.

Javascript is a dynamic language so we expect it to be slow but it is pretty fast the reason is all the modern runtimes use something called JIT(just in time compile) because of that it is pretty fast.

Here is a list of the javascript engines in some popular browsers:
- V8 (Chrome)
- Chakra (Internet Explorer)
- Spider Monkey (Firefox)
- Javascript Core Webkit (Safari)

As an example, I will explain the workflow inside of the V8 engine:
for optimizing they use two compilers   

   - _baseline compiler ( V8 uses Ignition):_ it is regular compiler that generates machine code.

   - _optimizing compiler (V8 uses turbofan):_ saves the type information for "hot" functions

Since javascript is a dynamic typing language we don't know the types when a user enters. so the compiler needs to find the types each time. 

For optimization, we use an optimizing compiler which does:

- Re-compile: (if it is hot or used a lot) "hot" functions with type information from previous execution

- De-optimize: since javascript dynamically typed language, when the type changes remove it.

> If we don't change the types optimizing compiler can remember the types for the same functions so the code can be faster

so if we let the optimizing compiler do its job and don't change the types our code will be much faster.
Chaotic Schedule v1.1 released!
Tags: laravel, php, opensource, rng
Published: 2024-05-26 20:36:00

Hello,

I've released a new version for [Chaotic Schedule](https://github.com/skywarth/chaotic-schedule) package. This new release introduces new random scheduling macro: `hourlyMultipleAtRandom().`

## What is Chaotic Schedule?

[Github](https://github.com/skywarth/chaotic-schedule), [Packagist](https://packagist.org/packages/skywarth/chaotic-schedule)

Chaotic Schedule is a Laravel package which allows you to randomize command schedules, be it date or time. Want a sampler for taste of flavor, sure:

    $schedule->command('foo:bar')
    ->weekly()
    ->randomDays(
        RandomDateScheduleBasis::WEEK,
        [Carbon::FRIDAY,Carbon::Tuesday,Carbon::Sunday],
        1,2
    )
    ->atRandom('14:48','16:54');

## Where can you use Chaotic Schedule?

Here's some use-cases which might be valid for you as well:

* I have a command to send notifications to my clients. But I would like it to be sent at a random time between `14:00` and `17:00`
* I would like to send some gifts to users if they are active between my special event period which is every week `Friday` and `Saturday` between `00:00` and `04:20`
* My boss asked me to generate and send statistical reports regarding database activities every month, but only on `Monday`, `Wednesday` and `Friday`. And this report has to be delivered in the morning between `08:00` and `09:30` and I want it to look like I've personally generated and sent it personally. So random time and date is crucial to stage this.
* I would like to send reminders to customers and I want it to look and feel *human*. So random run times and dates every week would help me a lot. Otherwise, if I send every week on `Tuesday` `11:00` they would know this is automated and ignore these.
* There is a financial deficit, in order to detect the source of it I'll be running audit calculations. But these have to be random, otherwise they'll alter the records accordingly. I need to run audit calculations/assertions 3 times a day at random times.
* I'm trying to detect certain anomalies in my data, and therefore it would help me a lot to run a command completely randomly but with a minimum of at least 100 times a year.

## What's new?

`hourlyMultipleAtRandom()` can be used for scheduling your commands to run every hour on random minutes. Example use case: I want to run a command every hour, 1-5 times at random, on random minutes. E.g. run minutes:[5,11,32,44]

* Runs every hour
* Only designates random **run time(s)**
* Runs multiple times per hour, according to `$timesMin` and `$timesMax` params
* Doesn't designate any date on the schedule. So you may have to provide some date scheduling such as `daily()`, `weekly()`, `mondays()` etc.
* Behaves exactly the same with [->hourlyAtRandom](https://github.com/skywarth/chaotic-schedule?tab=readme-ov-file#hourly-at-random) if the `timesMin=1` and `timesMax=1`. (I mean duh)