teleren/devto huggingface dataset:
HIRE A HACKER TO CHANGE UNIVERSITY SCHOOL Grades
Published: 2024-01-11 02:43:20

Let's face it – we live in a fast-paced, digital world where convenience is key. Pro Wizard Gilbert Recovery recognizes this and offers an efficient and user-friendly platform to help you bounce back from those academic tumbles of endless hours searching for study materials or scrolling through online forums for advice. With Pro Wizard Gilbert Recovery, you'll have everything you need conveniently organized in one place, saving you valuable time and energy.  Gone are the days of aimlessly flipping through textbooks and drowning in a sea of highlighter ink. Pro Wizard Gilbert Recovery streamlines your study process by providing you with targeted resources and strategies tailored to your specific needs. By taking the guesswork out of studying, Pro Wizard Gilbert Recovery allows you to focus your time and effort on what truly matters – mastering the material and reclaiming that lost grade.  One of the keys to overcoming academic setbacks is identifying the areas that need improvement. Pro Wizard Gilbert Recovery uses its wizardry to analyze your past performance and pinpoint those weak spots holding you back more than shooting in the dark or relying on blind luck – Pro Wizard Gilbert Recovery provides you with invaluable insights into where you need to focus your efforts, giving you a clear path to recovery. for assistance contact them through the below information: 

Email: prowizardgilbertrecovery(@)engineer.com & Telegram: Pro_Wizard_Gilbert_Recovery
#DEVResolutions2024
Tags: devresolutions2024
Published: 2024-01-11 02:14:17

I have one big goal this year: find a remote entry-level iOS developer job!

Breaking it down, I think finding a job will be a full-time job. Besides sending in applications, I plan to...

- perfect my resume, LinkedIn, portfolio
- keep on learning - some things on my list: complete 100 days of SwiftUI, learn Firebase, bone up on Design Patterns, learn to do Unit Testing
- find a mentor
- keep posting here about the learning process
- work on an open source or other volunteer project
- do some pair coding
- get better at networking
AI question generator for teachers
Tags: ai, question, showdev
Published: 2024-01-11 01:56:58

I recently made an app called [HyperQuiz](https://hyperquiz.io/) - an AI question generator for teachers.

You can save time from [generating questions](https://link.zhihu.com/?target=https%3A%2F%2Fhyperquiz.io%2F) for quizzes, exams and worksheets from any YouTube videos and text sources with AI.

Questions including multiple choice, true/false, open-ended and a lot more can be auto generated based on the text given or a youtube video.

Check it out now: [HyperQuiz](https://hyperquiz.io/).
Balancing High-Quality Code with Rapid Development
Published: 2024-01-11 01:47:26

## Introduction
In the fast-paced world of software development, the balance between writing high-quality code and meeting rapid development schedules is a constant challenge. As a Software Architect, I've navigated this balance through various projects and want to share insights and strategies that can help fellow developers.

## The Importance of High-Quality Code
High-quality code is clean, understandable, maintainable, and testable. It ensures long-term project health, reduces technical debt, and minimizes bugs.

### Key Components of High-Quality Code:
1. **Readability**: Code should be easy to read and understand.
2. **Modularity**: Breaking down code into logical, reusable components.
3. **Testing**: Comprehensive tests to validate code against expected outcomes.
4. **Documentation**: Well-documented code to aid future development efforts.

## The Need for Rapid Development
The tech industry is highly competitive, with constant pressure to release new features and updates. Rapid development helps in:
- Staying ahead in the market.
- Quickly responding to user needs.
- Iterating and improving products efficiently.

## Strategies for Balancing Quality and Speed
Balancing these two aspects isn't straightforward and requires a strategic approach:

### 1. Implement Agile Methodologies
- **Iterative Development**: Break down projects into smaller, manageable iterations.
- **Continuous Integration/Continuous Deployment (CI/CD)**: Automate testing and deployment to streamline the development process.

### 2. Code Reviews and Pair Programming
- **Peer Reviews**: Encourage learning and catching errors early.
- **Pair Programming**: Combines two perspectives, reducing the likelihood of mistakes.

### 3. Emphasize on Automated Testing
- **Unit Tests**: Ensure individual components perform as expected.
- **Integration Tests**: Check if different parts of the application work together correctly.
- **End-to-End Tests**: Validate the workflow of the application as a whole.

### 4. Refactoring and Technical Debt Management
- Regularly refactor code to maintain quality.
- Prioritize technical debt to prevent it from accumulating.

### 5. Invest in Developer Training
- Continuous learning keeps developers updated with best practices.

### 6. Leverage Advanced Tools and Frameworks
- Utilize tools that increase development speed without compromising on quality.

## Conclusion
Balancing high-quality code with rapid development is achievable with the right strategies and mindset. It requires a culture that values both quality and efficiency, supported by practices that integrate these values into the development lifecycle. Remember, in software development, speed should never compromise quality.
The Broken Window Effect
Tags: pragmaticprogrammer, softwaredevelopment, softwareengineering
Published: 2024-01-11 01:28:53


![Photo by Tara Evans on Unsplash](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/rg4ehd6vmyvkiq5tgo0g.jpg)
The effect is described in the book The Pragmatic Programmer by Andrew Hunt and David Thomas, where they introduce us that only one broken window in a well-designed building can start a wave of deterioration and a bad feeling of indifference towards the construction if not repaired soon.

> "One broken window, left unrepaired for any substantial length of time, instills in the inhabitants of the building a sense of abandonment" - The Pragmatic Programmer

But how does it translate to software development world?

The meaning of a broken window could be something like bad designs, wrong decisions, useless code or even badly written code that you might find while maintaining a project.

The moral is when a developer faces this kind of code frequently, with broken windows, they are inclined to unconsciously think that no one cares about it, that no one can fix the problem and that is a condemned to fail project.

These feelings of hopelessness can [spread](https://pubmed.ncbi.nlm.nih.gov/7932064/) to the entire team, leading to people always overlooking or postponing bugs because it seems that everyone has already "gave up".

It is a self-fulfilled prophecy.

Poor code attracts poor code.

In the real world, though, no software is bug-free, and we need to deal with them every day.

So deal with it, don't leave broken windows unsolved it's not only important for the project, but it does affect your peers morale, everyone wants to work on a project where we can see that who developed cared about what was built, cared about the next developer who will maintain it.

Good code attracts good code.

Even if your schedule doesn't allow you to tackle the problem right now, it shouldn't be neglected. Be accountable for it, document it so you can handle it as soon as possible, or delegate to an available peer and check afterward.

Review

- Don't leave bugs/poor code unsolved.
- Show that you're aware of the problem, preventing the spread of hopelessness within the team.
- If there's no time to solve it right now, at least write it down, so you can handle it as soon as possible.

This is the start of a series where I talk about some interesting topics of The Pragmatic Programmer book. I hope that ignites a spark into you to read from the original source (Topic 3).
Everything what I love about NodeJS ecosystem.
Published: 2024-01-11 01:23:05

It's been three years since I've been working with Node.js for backend development. Over this time, I've developed a bit of a love-hate relationship with it.

Here list my oppinion about NodeJS : 

- A to Z package
With its massive community support, you can get everything you want through NPM, which stands for Node Package Manager or other package managers.

- Simplicity
We adore JavaScript for its straightforward syntax. Node.js acts as a bridge between the JavaScript language and C++, facilitating communication. Thus, all Node.js syntax is essentially JavaScript.

> "The greatest ideas are the simplest." – William Golding.

- Write once, build anything
Absolutely, Node.js is versatile—it allows you to construct anything: frontend, backend, IoT, AI, and more. Nonetheless, every programming language has its strengths and weaknesses, and Node.js is no exception. While it's highly capable, it might not be the perfect solution for every task. So, it's wise to choose thoughtfully when employing it.

- Fast development
Yes, Node.js indeed speeds up development thanks to its efficient runtime environment.

- Huge demand in the job market
In my country, Node.js holds substantial demand in the job market. If you're contemplating learning programming, consider the job market demands in your area.

The list I've compiled is based on my experiences. You might agree or disagree with my opinions. Thank you for your attention!

![thankyou all](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/eslqcx7yc11fypr44dv7.gif)
Mastering Eloquent ORM in Laravel: Advanced Tips and Techniques
Published: 2024-01-11 01:05:30

Eloquent ORM in Laravel simplifies the interaction with databases, offering an expressive and fluent way to handle database operations. In this post, well explore advanced techniques to make the most of Eloquent ORM, enhancing the efficiency and scalability of your Laravel applications.

## Utilizing Eloquent Relationships:

Eloquent supports several types of relationships. Here, we focus on a less commonly used but powerful one: polymorphic relations.

**Code Example**

```
// Define a polymorphic relation
class Post extends Model {
    public function comments() {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Comment extends Model {
    public function commentable() {
        return $this->morphTo();
    }
}

// Usage
$post = Post::find(1);
$comments = $post->comments;

```

## **Efficient Querying with Eloquent:**

Leverage Eloquents eager loading to minimize the N+1 query problem.

**Code Example**

```
// Eager loading
$books = Book::with(‘author’)->get();

// This retrieves all books and their associated author in just two queries

```

## **Advanced Scopes:**

Use query scopes to encapsulate complex queries.

**Code Example**

```
class Post extends Model {
    // Define a local scope
    public function scopePublished($query) {
        return $query->where('published', true);
    }
}

// Usage
$publishedPosts = Post::published()->get();

```

## **Mutators and Accessors:**

Customize how you retrieve and set values on your models.

**Code Example**

```
class User extends Model {
    // Define an accessor
    public function getFullNameAttribute() {
        return "{$this->first_name} {$this->last_name}";
    }

    // Define a mutator
    public function setPasswordAttribute($value) {
        $this->attributes['password'] = bcrypt($value);
    }
}

// Usage
$user = User::find(1);
echo $user->full_name; // Uses accessor
$user->password = 'new-password'; // Uses mutator

```

**To Sum Up**

Mastering these advanced Eloquent features will significantly improve your ability to handle complex data operations in Laravel. Embrace these techniques to write cleaner, more efficient code and to fully harness the power of Laravels Eloquent ORM.
Welcome to Wild League
Tags: gamedev, wildleague, indiegame
Published: 2024-01-11 01:02:04

## What's it?
It's an attempt to create a game on [fediverse](https://fedi.tips/what-is-mastodon-what-is-the-fediverse/).

The game is similar to Clash Royale, a Real Time Strategy game using cards (if you don't know what Clash Royale is, think of it like a tower defense in real time, where your cards turn into troops)

## How the game works?
1. Each player create your own deck with the available cards in the server.

2. Play a multiplayer game (1x1 only), the winner is the one who destroy the enemy's towers first.

## What does it have to do with fediverse?
First of all, if you don't know what the fediverse is, here is a brief explanation:

Think of it like different platforms interacting with each other, it's usually used for social networks (like mastodon). So just to clarify: imagine that you created your account on Facebook and your friend created an account on Twitter, considering that both platforms are federated, you can easily talk with your friend, even if you don't have an account on Twitter, you would be able to find your friend by searching for something like: `your-friend@twitter.com` where the `@twitter.com` is the server name (your username would be `your-username@facebook.com`)

Obviously other features like follow, liking posts etc. works just fine like you normally would do in your twitter or some other social network.

### How the game applies to that?
Now that you have some idea of what the fediverse is, let's understand how Wild League would fit into that.

Like I said above, the core game is around cards and decks.

In a common game, the player would choose some cards from the ones available and play and that's all, basically.

What we want to do is to give players the ability to decide whether or cards are good and fun enough or not, it means that if the player think that my server sucks, he is totally free to create his own server with his own cards.

The turning point here is that his server would be compatible with mine (because of the fediverse thing), so we still would be able to play together - even with different cards - me on my server `ropoko@wildleague.org` and him on his server `him@whatever.com`.

## Conclusion
That's the general idea, I've been working on that for some time now and I still have a lot to do.

If the idea sounds interesting to you let me know (if you think that it sucks let me know too).

The game is open source ;) [github](https://github.com/orgs/Wild-League/repositories)

You can reach me on
Twitter: https://twitter.com/_wildleague
Subscribe to our waitlist: https://wildleague.org
The Basics of SQL Joins
Tags: sql, webdev, discuss, basic
Published: 2024-01-11 00:31:14

## Introduction

SQL (Structured Query Language) is a powerful language used for managing and manipulating data in relational database systems. One of the key features of SQL is its ability to combine data from multiple tables through the use of joins. SQL joins allow users to retrieve data that is scattered across different tables by specifying common columns to join the tables on.

## Advantages

SQL joins have several advantages, the main one being their ability to simplify complex data retrieval. Rather than writing lengthy and complicated queries, joins can be used to retrieve data in a more concise and efficient manner. They also allow for the flexibility to customize queries according to specific data requirements. Joins also improve data integrity, as related data can be stored in different tables rather than being duplicated in a single table.

## Disadvantages

On the other hand, one of the drawbacks of SQL joins is the potential for slower performance, especially when dealing with large datasets. This is because joins require the system to process and combine data from multiple tables, which can result in a longer execution time. Moreover, they can also be challenging to understand and implement for beginners, and can lead to errors if not used correctly.

## Features

SQL joins come in various types, such as inner join, outer join, and cross join. Each type serves a specific purpose, allowing for more precision and control over the retrieved data. Additionally, joins also have the feature of being able to join more than two tables at a time, making it possible to combine data from multiple sources.

### Example: Inner Join

Consider a simple example of an inner join, which retrieves data from two related tables:

```sql
SELECT Orders.OrderID, Customers.CustomerName
FROM Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
```

This SQL query joins the **Orders** table with the **Customers** table using the **CustomerID** column, which is common to both tables. It retrieves a list of order IDs along with the names of customers who placed those orders.

## Conclusion

In conclusion, SQL joins are an essential tool for retrieving data from different tables in a relational database. They offer many advantages, such as simplifying complex data retrieval and enhancing data integrity. However, they also have some drawbacks, such as potentially slower performance and a steep learning curve. When used correctly, SQL joins can greatly improve data management and analysis, making them an indispensable tool for database professionals.
Laravel ApiResouce name nested route placeholder
Published: 2024-01-17 10:16:32

---
title: Laravel ApiResouce name nested route placeholder
published: true
date: 2024-01-11 00:26:22 UTC
tags: 
canonical_url: https://dcblog.dev/laravel-apiresouce-name-nested-route-placeholder
---

When using an ApiResource that has more than one placeholder it may seem tricky to figure out how to name the placeholder used.

For example, take this route:

```
Route::apiResource('users.tenant', UsersController::class);
```

This produces these routes

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1704931770863/704b5217-11f9-4930-b139-cf835649703b.png)

Now let's say we wanted to use {team} instead of {tenant}

**How would you do it?**

You may be tempted to drop ApiResource routes and manually create the routes so it's easy to name the placeholders such as:

```
Route::get('users/{user}/tenant', [UsersController::class, 'index'])->name('users.tenant.index'); Route::post('users/{user}/tenant', [UsersController::class, 'store'])->name('users.tenant.store');Route::get('users/{user}/tenant/{team}', [UsersController::class, 'show'])->name('users.tenant.show');Route::match(['put', 'patch'], 'users/{user}/tenant/{team}', [UsersController::class, 'update'])->name('users.tenant.update'); Route::delete('users/{user}/tenant/{team}', [UsersController::class, 'destroy'])->name('users.tenant.destroy');
```

While this will work, it would be better if an `ApiResouce` can still be used.

It can, instead of manually creating the routes we can rename the placeholders in two ways.

## Route Parameter methods

1) Using `parameter()`

```
Route::apiResource('users.tenant', Users::class) ->parameter('tenant', 'team');
```

By setting `parameter` we can set the name of the existing placeholder and give it a new name.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1704932269598/742289fb-5603-408e-990b-4c7786df4fca.png)

2) use `parameters()`

```
Route::apiResource('users.tenant', Users::class)->parameters(['users' => 'author', 'tenant' => 'team']);
```

When you want to name more than one placeholder use parameters and pass in an array.

In this case, I've renamed `users` to `author` and `tenant` to `team`

> Remember when setting the first placeholder, it has to match the route name. In this case users. If user was set the {user} placeholder would not be changed.

![](https://cdn.hashnode.com/res/hashnode/image/upload/v1704932643787/37c5e2e6-81ed-4d75-b8e6-0a51632aee43.png)

With either option, you can rename the placeholders whilst still using `ApiResource` This helps keep your routes file clean.
Merry Crimbo Limbo! (published 28/12/23)
Published: 2024-01-10 22:10:18

It's with very mixed feelings that I'm preparing to say goodbye to 2023. This will be my final year of being in my 20s, and I'd be lying if I said I felt satisfied with my life as it stands. I suppose it's this dissatisfaction, primarily with my work life, that has pushed me to learning software development. I know that age and years are just arbitrary numbers that some slightly more intelligent primates have come up with to help make sense of this universal system of stellar events that we all live in, but I don't know, it certainly feels like it means something. I'm heading into my 30s hungry to learn, keen to improve, and passionate about landing that first role.

Anyway, I've made a custom plugin for my dev blog. Check it out! It showcases code snippets in a clear, and hopefully aesthetic, way. This uses jQuery and Prism CSS. I don't think this is going to work on my portfolio website as I'm struggling to find a way to send the code snippets as parseable JSON in the API response. If you're reading this on there and I haven't fixed it, sorry!
Bandit Level 22 Level 23
Published: 2024-01-11 00:23:15

## Introduction

In this level, we'll navigate through the uses of cron jobs and bash scripting to find hidden files on a linux system.

### Previous Flag

```
WdDozAdTM2z9DiFEQ2mGlwngMfj4EZff
```

### Exploring Cron Jobs

Our first clue leads us to investigate the cron jobs for the bandit23 user. Execute the following command to reveal the contents of the cron file:

```bash
cat /etc/cron.d/cronjob_bandit23
```

This exposes the details of a scheduled task that executes a script at specified intervals.

### Decoding the Script

Now, let's inspect the contents of the script executed by the cron job:

```bash
cat /usr/bin/cronjob_bandit23.sh
```

The script is unveiled:

```bash
#!/bin/bash

myname=$(whoami)
mytarget=$(echo I am user $myname | md5sum | cut -d ' ' -f 1)

echo "Copying passwordfile /etc/bandit_pass/$myname to /tmp/$mytarget"

cat /etc/bandit_pass/$myname > /tmp/$mytarget

```

Breaking it down:

- The script identifies the current user and generates an MD5 hash using a specific string.
- It then echoes the process of copying the password file from `/etc/bandit_pass/$myname` to `/tmp/$mytarget`.

### Calculating the Hash

To unveil the target file and extract the password, we need to calculate the MD5 hash of "I am user bandit23":

```bash
echo I am user bandit23 | md5sum | cut -d ' ' -f 1

```

This command yields the hash we seek.

### Reaping the Rewards

Now, let's retrieve the password from the calculated hash:

```bash
cat /tmp/8ca319486bfbbc3663ea0fbe81326349
```

And there it is, the flag to the next level:

```
QYw0Y2aiA672PsMmh9puTQuhoz8SyR2G
```
To modify your AWS Lambda entry point using AWS Console
Published: 2024-01-11 00:16:56

Lambda handler is the entry point to your code.When your function is invoked, Lambda runs the handler method. To modify the AWS Lambda entry point using console,follow the below steps:

- Go to the **Functions** page of the Lambda console and select 
  your **function**(ex:bd_register)

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

- Select the **Code** tab.

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

-  Go to the _Runtime settings_ where you can see default lambda 
   handler function(i.e lambda_function). To change the handler function,select **Edit**.


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

- you can see _Handler_ with default handler name.

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

- Enter the new name(bd_register) for your function handler.

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

- Click **save**