teleren/devto huggingface dataset:
Revolutionizing Cleanup: The Sterling Heights Dumpster Rental Experience
Tags: residentialdumpster
Published: 2024-02-19 01:43:34


Embarking on or tackling a massive decluttering task? Look no further than Sterling Heights dumpster rental services to revolutionize your cleanup experience. In this bustling city where community matters, having a seamless waste management solution is crucial, and renting a dumpster provides just that.

1. Tailored Solutions for Varied Needs: Sterling Heights understands that no two projects are alike. Whether you're renovating a kitchen, clearing out the garage, or overseeing a construction site, the city's dumpster rental services offer a range of sizes tailored to meet your specific requirements. This customization ensures that you're not paying for more than you need while still having ample space to dispose of your waste effectively.

2. Effortless Booking and Delivery: Streamlining your cleanup starts with a straightforward booking process. Sterling Heights dumpster rental companies simplify the entire experience through user-friendly online platforms. With a few clicks, you can select the dumpster size, choose a delivery date, and have the container dropped off at your location. Effortless booking and delivery are at the core of making waste management a stress-free endeavor.

3. Transparent and Affordable Pricing: Say goodbye to hidden fees and unexpected costs. Sterling Heights dumpster rental services pride themselves on transparent and affordable pricing structures. You'll know exactly what to expect, allowing you to plan your budget effectively. This transparency extends to rental periods, ensuring you have the flexibility you need without breaking the bank.

4. Community-Focused Sustainability: Sterling Heights is a community that values sustainability, and the dumpster rental services mirror this commitment. Many rental companies prioritize environmentally friendly waste disposal methods, complying with local regulations and minimizing the environmental impact of your cleanup project. Contributing to a cleaner, greener community is a shared goal that resonates with the values of Sterling Heights residents.

5. Timely Pickup and Disposal: Once your project is complete, the last thing you want is to be stuck with a dumpster indefinitely. Sterling Heights rental services understand this, providing timely pickup services. As soon as you're ready, they'll promptly retrieve the dumpster and ensure your waste is disposed of responsibly. This efficient process saves you time and ensures your cleanup is completed seamlessly.

Sterling Heights dumpster rental services go beyond just providing a container – they offer a transformative cleanup experience. With tailored solutions, effortless booking, transparent pricing, community-focused sustainability, and timely services, renting a dumpster in Sterling Heights becomes a pivotal element in simplifying and enhancing your waste management journey. Choose the path of convenience and community stewardship with Sterling Heights dumpster rentals!
the objective
Tags: gamedev, writing
Published: 2024-02-25 21:29:10

---
title: the objective
published: true
date: 2024-02-19 00:00:00 UTC
tags: [ 'gamedev', 'writing' ] 
canonical_url: https://onwriting.games/daily/20240219-839-the-objective/
---

The player generally has a clear goal, and uses the game mechanics to achieve that objective.

Sometimes it is very explicit, like "Collect 20 bat wings".

But other times, it is not so explicit, to the point that there are games where the objective is simply to go through the experience, as is the case with walking simulators.

When we design our stories, we want to make a decision regarding the objective.

Is exploring the options a sufficient objective to entertain the player?

Do we want to make the objective explicit?

Do we want multiple specific objectives that unlock in different branches?

Or do we not want the player to have anything else in mind other than our story?

Do we have micro-objectives or more long-term ones?

PS: I'm dealing with a burnout crash. This is a known cycle for me (as it is for many ADHDers), I load up on commitments and then crash. That means that I have to navigate my energies as better as I can. I'll try to write every day, but I can't promise it right now, hope you're still happy with what I write and stick with me. Have a great week!
Ibuprofeno.py💊| #53: Explica este código Python
Tags: python, spanish, beginners, learning
Published: 2024-02-19 01:36:25

## **<center>Explica este código Python</center>**
#### <center>**Dificultad:** <mark>Intermedio</mark></center>

```py
## Reto #53
print([0,0,0] > [2,0,10])
```

👉 **A.** `True`
👉 **B.** `False`
👉 **C.** `None`
👉 **D.** `SyntaxError`

---

Respuesta en el primer comentario.
Design Pattern: Composite
Tags: programming, designpatterningolan
Published: 2024-03-05 05:38:01

---
title: Design Pattern: Composite
published: true
date: 2024-02-19 01:27:51 UTC
tags: programming,designpatterningolan
canonical_url: 
---

![A colorful painting of a gift box of mangos, in the style of 1800s, pixel art](https://cdn-images-1.medium.com/max/1024/0*bJF-8sqTEMlKyrIN.png)

We can consider a single type or a composition of related types to be the same by:

- Creating a new type, usually an interface, to represent them, called **Component**.
- Allowing recursive structure, meaning Component can contain other child Components. Components within this structure are called **Composite** , while those without any children are called  **Leaf**.

### When to Use

1. When representing hierarchical systems.
2. When disregarding the difference between a single object and a composition of objects, treating them all as a Component.

### Implementation

#### Structure

Let's take the example of a UI framework (something like React). UIComponent represents all types of components such as buttons, text, etc. We also have Popup, which is a more complex component, composed of a button and a text, making it a Composite.

#### Sample Code

**Component** interface:

```
type UIComponent interface {
  Render()
}
```

Some **Leaf ** types:

```
type Text struct{}
func (t *Text) Render() {
  fmt.Print("hello")
}

type Button struct{}
func (b *Button) Render() {
  fmt.Print("button: ")
}
```

Composite:

```
type Popup struct {
  children []UIComponent
}

func (p *Popup) Render() {
  for _, c := range p.children {
    c.Render()
  }
}
```

Usage:

```
text := &Text{}
button := &Button{}
popup := &Popup{
  children: []UIComponent{button, text},
}
popup.Render()

// Output:
// button: hello
```

This pattern offers a way to treat individual objects and compositions uniformly, providing a unified way to work with both. Moreover, we can freely switch the types behind UIComponent interface without affecting the users.

### Testing

This is a pure pattern for building a structure, so I think we can skip this part 😇

### Related patterns

#### Chain Of Responsibility

If we add the parent UIComponent field to UIComponent interface, we can create a usable structure for the [Chain Of Responsibility](https://mangotree30.substack.com/p/chain-of-responsibility-pattern) pattern. Check out the pattern's article for more details.

#### Iterator

Iterator can be used to iterate through each component in the Composite structure.

#### Visitor

Helps gather the logic of the components in one place instead of being scattered across Composites and Leaves.

#### Decorator

Often used in conjunction with Composite. Check out the Decorator Pattern for more details.

* * *
Keeping an Eye on the Cloud: Understanding Prometheus
Tags: devops, monitoring, prometheus, cloud
Published: 2024-02-19 01:14:56


![prometheus-monitoring-image](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hv0ybx2419iiociscp01.png)
Ever wondered how tech giants like SoundCloud ensure their systems run smoothly? Enter Prometheus, the open-source “doctor” of the cloud! Developed by SoundCloud itself, Prometheus joined the Cloud Native Computing Foundation (CNCF) in 2016, becoming the second project after the famous Kubernetes.

So, what exactly does Prometheus do? Put simply, it monitors and alerts you about the health of your cloud systems. Imagine it as a fitness tracker for your servers, constantly checking their pulse (CPU usage), temperature (memory usage), and activity levels (network traffic). But there’s a twist!

Prometheus doesn’t just give you a single number. It tracks changes over time, like a detailed heart rate monitor. This way, you can see trends and easily spot potential issues before they become major headaches.

But wait, there’s more! Prometheus takes things further with “labels”. Think of them as tags on your fitness tracker that tell you more about your activity. You can label metrics based on factors like server location, application type, or user region. This granular data lets you zoom in on specific parts of your system and pinpoint problems quickly.

Overall, Prometheus is a powerful tool for anyone managing cloud systems. It provides real-time insights, historical trends, and detailed breakdowns, helping you keep your cloud running smoothly and efficiently. And with its open-source nature and strong community support, it’s a popular choice for businesses of all sizes.

So, the next time you think about the cloud, remember the silent guardian watching over it: Prometheus, the open-source champion of cloud monitoring!

**I hope you found this article informative! What are your biggest takeaways about Prometheus? Share your thoughts in the comments below, and if you enjoyed this, consider liking this article and following me for more insights on cloud technologies.**
ARE YOU A VICTIM OF CRYPTO FRAUD? CONTACT PRO WIZARD GILBERT RECOVERY
Published: 2024-02-19 00:46:34

A growing number of experienced and beginner investors are drawn to cryptocurrency investments due to their growing popularity. But because cryptocurrencies are digital, there's a chance that they could be lost accidentally, stolen, or the target of a hack. Thus, the necessity for efficient techniques for recovering cryptocurrency assets has grown. You know that terrifying moment when you realize you've misplaced your crypto assets? Yeah, it's like finding out you left the stove on after leaving the house - panic mode activated. With more and more people being involved in the cryptocurrency space, recovering cryptocurrency assets has become a critical concern. Since these digital currencies are decentralized, there is no bank or customer support hotline that you may contact for assistance. Web recovery solutions come to the rescue in this situation. As the crypto market explodes like a fireworks display, the need for web recovery solutions has skyrocketed. These tools act as a much-needed safety net for crypto investors, providing a lifeline to retrieve lost or stolen assets. Think of them as the crypto equivalent of a trusty superhero sidekick, rescuing your digital wealth from the clutches of misfortune. With cyber threats lurking around every corner of the internet, having a reliable web recovery solution is crucial for any crypto investor looking to sleep soundly at night. The enchanted answer to all of your concerns about protecting your cryptocurrency assets is here: Pro Wizard Gilbert Recovery. This tech wizard is coming to protect your priceless cryptocurrency holdings with a spell of protection. An unique web-based technology called Pro Wizard Gilbert Recovery was created especially for cryptocurrency investors who wish to protect and recover their funds in case of emergency. It provides you complete control over your cryptocurrency empire by fusing state-of-the-art technology with an intuitive user interface. Pro Wizard Gilbert Recovery is like having a trusty sidekick who has your back in the face of danger. It offers a range of benefits that make it the go-to choice for crypto asset protection. Firstly, it provides a seamless account recovery process, so you can breathe easy knowing that if you lose access to your crypto accounts, Pro Wizard Gilbert Recovery will swoop in to save the day. Contact 
Pro Wizard Gilbert Recovery through: Email: prowizardgilbertrecovery(@)engineer.com & Telegram: @Pro_Wizard_Gilbert_Recovery
Introduction to NoSQL Databases: Working with MongoDB
Tags: mongodb, nosql, database, javascript
Published: 2024-02-19 00:30:22

## Introduction

NoSQL databases have revolutionized the way we handle large amounts of data in recent years. Traditional relational databases often struggle to keep up with the exponential growth of data and increasing demand for high performance. This is where NoSQL databases come in, offering a more flexible and scalable solution. One of the most popular NoSQL databases is MongoDB, a document-oriented database that uses a flexible data structure. In this article, we will take a closer look at what MongoDB is and its advantages and disadvantages.

## Advantages

- **Scalability and Performance:** One of the main advantages of MongoDB is its ability to handle large amounts of data and its scalability.
- **Flexible Data Model:** It offers a flexible data model, where data is stored in documents rather than tables, making it easier to adapt to changing data needs.
- **Sharding:** MongoDB supports sharding, which allows for distributing data across multiple servers, resulting in better performance.
- **High Availability:** It has built-in replication and automatic failover, ensuring high availability for critical applications.

## Disadvantages

- **ACID Transactions:** MongoDB's lack of support for ACID transactions is considered a disadvantage by some.
- **Data Modeling Considerations:** It requires careful consideration of data modeling to avoid performance issues.
- **Schema Flexibility:** The lack of a strict schema can lead to data inconsistency if not managed properly.

## Features

- **Indexing and Aggregation:** MongoDB offers features such as indexing, aggregation, and geospatial indexing, making it suitable for a wide range of use cases.
- **Rich Query Language:** It also has a rich query language and a robust set of documentation and user support.

### Example of a Basic MongoDB Operation

```javascript
// Connecting to a MongoDB database
const MongoClient = require('mongodb').MongoClient;
const url = "mongodb://localhost:27017/mydb";

MongoClient.connect(url, function(err, db) {
  if (err) throw err;
  console.log("Database created!");
  db.close();
});
```

This code snippet demonstrates how to connect to a MongoDB database using the MongoDB Node.js driver.

## Conclusion

NoSQL databases, and specifically MongoDB, have gained popularity due to their flexibility, scalability, and performance. While it may not be suitable for all use cases, it offers a viable alternative to traditional relational databases. As technology continues to advance and data continues to grow, NoSQL databases like MongoDB will play a crucial role in managing and analyzing large amounts of data efficiently.
Exploring Deques in Python
Tags: python, beginners, programming
Published: 2024-02-19 00:08:48

In this post, we'll explore deques in Python, using an astronomy theme to provide code examples. Deques, short for double-ended queues, are a generalization of stacks and queues. They support adding and removing elements from both ends with approximately the same O(1) performance. Let's get started.

First, let's create a deque of planets in our solar system:

```{python}
from collections import deque

planets = deque(["Mercury", "Venus", "Earth", "Mars", "Jupiter", "Saturn", "Uranus", "Neptune"])
print(planets)

# Output: deque(['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune'])
```

In this example, we create a deque called `planets` containing the names of the eight planets in our solar system.

We can add elements to either end of a deque using the `append` and `appendleft` methods:

```{python}
planets.append("Pluto")
print(planets)

# Output: deque(['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto'])
```

```{python}
planets.appendleft("Ceres")
print(planets)

# Output: deque(['Ceres', 'Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune', 'Pluto'])
```

In this example, we add the dwarf planet Pluto to the right end of our deque of planets using the `append` method, and the dwarf planet Ceres to the left end using the `appendleft` method.

We can remove elements from either end of a deque using the `pop` and `popleft` methods:

```{python}
pluto = planets.pop()
print(pluto)

# Output: Pluto
```

```{python}
ceres = planets.popleft()
print(ceres)

# Output: Ceres
```

In this example, we remove and return the rightmost element from our deque of planets using the `pop` method, and the leftmost element using the `popleft` method.

We can also insert elements into a deque at a specific position using the `insert` method:

```{python}
planets.insert(3, "The Moon")
print(planets)

# Output: deque(['Mercury', 'Venus', 'Earth', 'The Moon', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune'])
```

In this example, we insert the Moon into our deque of planets at position 3 using the `insert` method.

We can remove a specific element from a deque using the remove method:

```{python}
planets.remove("The Moon")
print(planets)

# Output: deque(['Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter', 'Saturn', 'Uranus', 'Neptune'])
```

In this example, we remove the Moon from our deque of planets using the `remove` method.

We can also rotate a deque by a specified number of steps to the right using the `rotate` method:

```{python}
planets.rotate(3)
print(planets)

# Output: deque(['Saturn', 'Uranus', 'Neptune', 'Mercury', 'Venus', 'Earth', 'Mars', 'Jupiter'])
```

In this example, we rotate our deque of planets three steps to the right using the `rotate` method.

That concludes our introduction to deques in Python. We've covered the basics of creating and accessing deques, as well as some of their useful methods. Deques are a powerful tool for working with collections of elements, and can be a useful addition to your Python toolkit.
Introducing Versa - the versatile CLI tool
Tags: php, symfony, opensource
Published: 2024-02-23 16:00:51

---
title: Introducing Versa - the versatile CLI tool
published: true
date: 2024-02-19 00:00:00 UTC
tags: [php, symfony, opensource] 
canonical_url: https://www.oliverdavies.uk/archive/2024/02/19/introducing-versa
---

Today, I started to build a new open-source project - Versa, the versatile command-line tool that standardises common commands across projects.

After watching a Twitch streamer building something similar in Rust, I decided to build my take on it and add features I'd need, such as support for local vs Docker-based commands and to run different commands for different projects.

For example, `versa run` would need to run different commands for Drupal and Sculpin projects, `versa test` should support different test frameworks for the same language - e.g. PHPUnit, Pest and ParaTest for PHP - and the commands will need to be different in Docker Compose-based projects.

Currently, this logic is within my [Build Configs](https://www.oliverdavies.uk/build-configs) project but can be moved to Versa.

This reduces the complexity within that codebase and means I can open-source it as it's a separate project.

At the moment, I've added PHP as the only supported language but I will add JavaScript/TypeScript support so it supports projects like Fractal.

It's still in the prototype phase and includes some initial commands, but the interesting parts will be making it clever.

Instead of running `versa run --type sculpin`, I'd like to just do `versa run` and have it determine the type of project automatically.

`versa test` should be able to determine the testing framework automatically based on what's in the project's `composer.json` file instead of having to specify it.

Likewise, for JavaScript, `versa install` should be able to determine if `npm`, `yarn` or `pnpm` is used.

That'll be where the more complex code will be added and when I start doing test-driven development - maybe with Behat, which is also something I've been thinking about for Build Configs.

Interested? [Take a look at the code](https://github.com/opdavies/versa).

P.S. Are you still using Drupal 7 and don’t know what’s involved to upgrade to Drupal 10? [Book a Drupal 7 upgrade consultation call](https://www.oliverdavies.uk/call) or [an upgrade roadmap](https://www.oliverdavies.uk/drupal-upgrade).
Groundwork SPA with a full-fledged CRUD generator
Tags: laravel, vue, php
Published: 2024-02-19 00:00:00

In the previous article, I described the SPA modules and provided you with a foundation for developing such an application. Now let's dive deeper into this project and its capabilities.

[https://github.com/Yurich84/laravel-vue3-spa](https://github.com/Yurich84/laravel-vue3-spa)

For the project, I chose Laravel and Vue3 with Composition API. Since the application is planned to be large, we will need a state manager system like Pinia. For authentication, we'll use [Vue-Auth](https://websanova.com/docs/vue-auth/home), [Axios](https://github.com/mzabriskie/axios), and [Sanctum](https://laravel.com/docs/8.x/sanctum).

For rapid development, the ElementPlus UI Kit was used. Also, there are libraries without which no large project can do:
- [Lodash](https://lodash.com/) js utilities
- [Day.js](https://dayjs.com/) time manipulations
- [FontAwesome 6](http://fontawesome.io/icons/) icons
- [VueRouter](https://router.vuejs.org/)
- [VueI18n](https://kazupon.github.io/vue-i18n/)

Since the modules are entirely independent, I created a set of templates for each module file and a command that allows generating a fully functional CRUD ready to use.

By executing the command `php artisan make:module {ModuleName}`, all necessary files will appear, including the model and migrations for a fully functional CRUD operation. You just need to execute migrations `php artisan migrate`, and everything will work. Along with this, a file with functional tests is generated to cover this CRUD. Most likely, you will need to add additional fields, so before migrating, don't forget to add them to the model, migration, and also display them in vue.

{% embed https://youtu.be/0qKNlrmhgNg %}

The first version of the application used older technologies but was no less useful. Here it is: [https://github.com/Yurich84/laravel-vue-spa-skeleton](https://github.com/Yurich84/laravel-vue-spa-skeleton). 

In the new project, I decided to change several libraries:
- Replaced Vuex with Pinia
- Moved to Vue3 Composition API
- Replaced moment.js with the lighter day.js
- Used Vite instead of webpack for the builder.

Initially, this groundwork was developed for my needs, but now I hope it will be useful for other users.