teleren/devto huggingface dataset:
AI-Based Learning Management System
Tags: webdev, hackathon, ai, react
Published: 2023-04-25 13:25:08

Few Days back, Our team 'HUGS FOR BUGS' with my team members Prasuk Jain, Mayuri Agrawal and Garvit Agrawal participated in Wittyhacks 3.0 presented by Datacode.in.

Our proposed solution for AI-based Learning Management System is - 

Artificial Intelligence (AI) has become a crucial aspect of our day-to-day lives. The data-driven technology is quickly spreading its wings, touching new horizons in every industry. The education industry is no different as an increasing number of educational institutions are now harnessing the vast AI potential to deliver improved learning experiences. 

We shall discuss the main benefits of developing custom AI-based Learning Management System to deliver improved learning experiences. Subsequently, we will talk about the ideal approach to get off the ground with your AI-driven LMS. 

Our solution based on Generative AI, Open-AI's API key to remove doubt in live session, one big problem is to mark student's attendance during live session, so we added a feature of streak so that if Attendance will be marked automatically if the student is attending the live session. We have developed video meeting server with use of peer programming and integrated chatting during session using socket.io in Javascript.

One of the major challenges in the education sector is that people learn differently and at different levels. Students undergo different levels of learning ability and aptitude. Some are adept at “left-brain” thinking with skills for analytical thought while others are skilled at “right-brain” thinking with creative abilities. With the potential to bring about unprecedented efficiency in the education sector, AI-based Learning Management System can redefine the way educators interact with students. 

AI systems can be used to deliver tailored and personalized learning for individual students. By leveraging the vast potential of machine learning-based hyper-personalization, we can create a custom learning profile for every student. Furthermore, the e-learning data can be customized based on their existing skills and abilities. We can also take into consideration several factors like the preferred mode of learning and course duration. 

AI and machine learning algorithms could be used to create digital and hyper-personalized content on-demand to deliver smart learning experiences.

In addition to customized materials, AI-based LMS significantly improve the learning experience with personal, conversational education assistants. The autonomous virtual agents can address students’ course-related queries and provide assistance for assignment completion. Besides, they provide features for adaptive learning so that the students can learn at their own pace.
Why developer marketers and devrel pros should be (internal) reporters
Tags: devrel, marketing
Published: 2023-04-25 13:24:14

Here’s an interesting contraction: The work of software engineering produces a lot of interesting text — as a matter of procedure — but developer content marketing tends to be mediocre. 🤔

Think about all the text that emerges from widely accepted software development practices: PR reviews, retrospectives, stand-up meeting notes, hackathon presentation decks, RFCs. The list goes on. 

The problem is that much of this content is internal and the people producing it either aren’t aware of how interesting it actually is or don’t know how to translate this work into appealing, approachable content for outsiders. 

One solution is to bring on a writer who’s as interested in reporting as writing. I’ve incorporated reporting into my content work both as an employee and as a freelancer and the results always surprise me.

When I worked full-time for the dev tool company Sourcegraph, I was almost overwhelmed with possibilities. 

Slack was bursting with channels I could snoop on; there were multiple internal newsletters that could keep me in the loop on new experiments and projects; there were endless sales call recordings to listen to; and, of course, there was GitHub, where I could find the traces and the results of enormous, fascinating efforts. 📚

I embraced my inner reporter (as well as my inner busybody) and read as much as I possibly could. And it really was like reporting because no single finding was sufficient for an article but plenty of findings formed leads that I could follow up on via Slack DMs or Zoom calls. 🕵️

As reporters well know, some of these leads went cold. Some leads were exciting but the work being done was still in progress; some leads looked interesting to me but not to an experienced developer; and some leads were only compelling seeds that needed more cultivation. 

The trick is being confident good content will emerge but humble enough to know that you won’t always be able to guess where and when it comes from. 🌱

You can predict, however, that if the development work is interesting, then the results of reporting on it will be interesting to other developers. 

But you can’t predict how or whether the stories you find will be easily recognizable. Here, it’s best to ditch inherited categories and familiar patterns like “thought leadership” and “blog post.”

Instead, embrace your inner reporter, immerse yourself in the work and the text that emerges from that work, develop a nose for interesting leads, and pursue those leads through more direct methods (or ask a freelance writer for help 😉). 

The initial result won’t always be fully-fledged content but it will almost always lead to or inform content down the line. Most importantly, you will take one of the hardest problems in developer marketing — how can non-technical marketers come up with enough (good) ideas to fuel a developer-first content strategy? — and solve it in one fell swoop. 

If you listen well enough, you’ll have more ideas than you can choose from. 👂
Plex
Published: 2023-04-25 13:21:13

# Plex

## Usage

```bash
cat > docker-compose.yml <<-'EOF'
# https://hub.docker.com/r/plexinc/pms-docker
# Port: 32400
version: "3"

services:
  plex:
    image: plexinc/pms-docker
    devices:
      - "/dev/dri:/dev/dri"
    network_mode: host
    restart: always
    volumes:
      - ./plex/config/:/config/
      - ./plex/transcode/:/transcode/
      - /:/data/

EOF
```
49 berufliches Vorwärtskommen: lästern.
Tags: deutsch, career, motivation, discuss
Published: 2023-04-25 13:16:10

Moin Moin,

in den vorherigen Beiträgen sind wir bereits indirekt und durch die Blume aufs Lästern eingegangen. Eine unschöne Angelegenheit, die leider Wirklichkeit sein kann. Ob jemand dies aus einer vermeintlichen Überlegenheit tut oder aus Missgunst, es stört die Gruppendynamik, wodurch die Angelegenheit auf Lästerer selbst zurückfällt. So sollte es zumindest in „gesunden“ Teams sein.

1) Habt ihr Erfahrungen mit Lästern am Arbeitsplatz gemacht? Was waren die Konsequenzen für den Lästerer?
2) Was können wir als Software-Entwickler tun, um derartigen Verhalten vorzubeugen?

Beste Grüße,
Mustafa

Austausch mittels E-Mail: mustafa.kevin.dwenger@posteo.de
Betreff: Austausch
Some Books that Every Programmer Should Read
Tags: beginners, webdev, productivity, career
Published: 2023-04-25 12:58:02

Many people may think that if you want to learn to program, you have to read a book or two and learn a programming language. For those just starting, it's fine. But you should know that to improve in this profession you need to read a lot of books. Programmers in our country are not as interested in coding as they are in reading and learning. And so their career ends in a short time.

One thing to think about is that after 5 years your salary will not be the same as the first year. If you still code like you did when you were a junior, what's the point of paying you more? You have to learn to design good and complex software, learn to manage teams, and much more. If you are busy coding after 3-4 years then this is a concern. And so the following books can help a lot to improve your skills. These books are widely known all over the world. If you don't understand one, read the other, keep reading, and read again and again. If you want to build a future, you have to do something, right?

[The Pragmatic Programmer: From Journeyman to Master](https://www.amazon.com/Pragmatic-Programmer-Journeyman-Master/dp/020161622X)

[The Mythical Man-Month: Essays on Software Engineering](https://www.amazon.com/Mythical-Man-Month-Software-Engineering-Anniversary/dp/0201835959)

[Refactoring: Improving the Design of Existing Code](https://www.amazon.com/Refactoring-Improving-Design-Existing-Code/dp/0201485672)

[Clean Code: A Handbook of Agile Software Craftsmanship](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882)

[Design Patterns: Elements of Reusable Object-Oriented Software](https://www.amazon.com/Design-Patterns-Elements-Reusable-Object-Oriented/dp/0201633612)

[Working Effectively with Legacy Code](https://www.amazon.com/Working-Effectively-Legacy-Michael-Feathers/dp/0131177052)

[Head First Design Patterns](https://www.amazon.com/Head-First-Design-Patterns-Brain-Friendly/dp/0596007124)

[Domain-Driven Design: Tackling Complexity in the Heart of Software](https://www.amazon.com/Domain-Driven-Design-Tackling-Complexity-Software/dp/0321125215)

[Programming Pearls](https://www.amazon.com/Programming-Pearls-2nd-Jon-Bentley/dp/0201657880)

[Test-Driven Development: By Example](https://www.amazon.com/Test-Driven-Development-Kent-Beck/dp/0321146530)

[Patterns of Enterprise Application Architecture](https://www.amazon.com/Patterns-Enterprise-Application-Architecture-Martin/dp/0321127420)

[Introduction to Algorithms](https://www.amazon.com/Introduction-Algorithms-3rd-MIT-Press/dp/0262033844)

[Peopleware: Productive Projects and Teams](https://www.amazon.com/Peopleware-Productive-Projects-Tom-DeMarco/dp/0932633439)
Using ENV file in React & Webpack
Tags: react, webpack, dotenv, variables
Published: 2023-04-25 12:48:31

1. Install dotenv-webpack:
`npm install dotenv-webpack --save-dev
`

2. Create separate .env files for each environment you want to configure. For example, you might have .env.development for development environment and .env.production for production environment.

3. Create a .env file containing the common environment variables shared across all environments.

4. Create a webpack.config.js file that uses dotenv-webpack to load the appropriate environment-specific .env file based on the NODE_ENV environment variable. Here's an example:

```
const path = require('path');
const webpack = require('webpack');
const Dotenv = require('dotenv-webpack');

module.exports = (env) => {
  const isProduction = env.NODE_ENV === 'production';
  const dotenvFilename = isProduction ? '.env.production' : '.env.development';

  return {
    entry: './src/index.js',
    output: {
      path: path.resolve(__dirname, 'dist'),
      filename: 'main.bundle.js',
    },
    plugins: [
      new Dotenv({
        path: dotenvFilename,
      }),
      new webpack.DefinePlugin({
        'process.env.NODE_ENV': JSON.stringify(env.NODE_ENV),
      }),
    ],    
  };
};
```

In this example, we're using Dotenv to load the environment variables from the appropriate .env file, based on the NODE_ENV environment variable. We're also using DefinePlugin to define a process.env.NODE_ENV variable that can be used in our code.

5. Update your package.json scripts to pass the NODE_ENV environment variable to the webpack command. For example:

```
{
  "scripts": {
    "start": "NODE_ENV=development webpack serve --mode development --open",
    "build": "NODE_ENV=production webpack --mode production"
  }
}

```

In this example, we're setting the NODE_ENV environment variable to development for the start script, and to production for the build script. Webpack will then use the appropriate .env file based on this environment variable.

And that's it! Now you can use environment-specific .env files with Webpack.

Bonus:
If you don't want to use dotenv-webpack plugins, you can update your webpack config code with

```
const path = require('path');
const webpack = require('webpack');

module.exports = (env) => {
  const isProduction = env.NODE_ENV === 'production';
  const envFile = isProduction ? '.env.production' : '.env.development';
  const envPath = path.resolve(__dirname, envFile);
  const envVars = require('dotenv').config({ path: envPath }).parsed || {};

  return {
    entry: './src/index.js',
    output: {
      path: path.resolve(__dirname, 'dist'),
      filename: 'bundle.js',
    },
    plugins: [
      new webpack.DefinePlugin({
        'process.env': JSON.stringify(envVars),
      }),
    ]
}
};

```

If `NODE_ENV=development` is not working in latest Webpack, use below command

`"start": "webpack serve --mode development --env NODE_ENV=development`

and now you can access it using env.NODE_ENV
How to scale and center path inside svg in javascript
Tags: html, javascript, css
Published: 2023-04-25 12:47:11

## 
<span style="width:80px; height:80px">
 <svg id="tooltip_svg" xmlns="http://www.w3.org/2000/svg" width="80" height="80" preserveAspectRatio="xMinYMin"fill="red" stroke="#282A35" viewBox="0 0 80 80" fill-rule="evenodd" clip-rule="evenodd" style="padding: 5px; border: 0; overflow: visible;">
<path d="M504 489L513 492L517 489L522 491L525 487L538 487L543 481L560 468L564 462L574 458L582 444L587 442L594 436L597 431L610 430L605 418L605 412L598 414L593 413L583 423L574 419L561 420L552 405L547 408L546 414L538 417L538 423L534 429L523 423L521 419L518 428L508 431L500 431L501 439L508 441L495 453L497 457L487 469L472 471L498 481z" />
  </svg>
</span>

## 
Pls i just want the path to take the entire svg size of 80/80,
Do developers dream of secure apps?
Tags: security, discuss, cybersecurity, programming
Published: 2023-04-25 12:37:18

![1047_DoDevelopersDreamOfSecurity/image1.png](https://import.viva64.com/docx/blog/1047_DoDevelopersDreamOfSecurity/image1.png)

Do developers care about code security? This question, I believe, is still open to debate\. I wrote this article to solicit feedback from both developers and security experts\. Would you help me with that?

I'll explain why this topic interests me\. 

I'm working on [PVS\-Studio](https://pvs-studio.com/en/pvs-studio/)\. Our tool detects both coding errors and security flaws\. Thus, PVS\-Studio combines the features of both a "typical" static analyzer and SAST solution\. 

I've been interested in PVS\-Studio being a SAST solution\. So, I'd like to know more about what teams expect from such tools\. What problems do they face when introducing SAST into the development process? What matters to them and what does not? How are workflows for handling analysis results managed?

Since the experience of integrating SAST is often discussed at security conferences, I listened to the talks seeking answers to these questions\. After watching a dozen talks, I was left with the idea that\.\.\. developers aren't truly interested in SAST\.

> Take it from me, developers would say a few choice words after they find that SAST has been brought into the development process\. 

I noticed a common idea in the talks: developers are not happy with the integration of SAST\. It's not easy to set up a workflow so that developers sort out and handle all the warnings\.

However, SAST helps to find some security problems\. That's why teams developing secure SDLC integrate SAST into the development process\. While different companies take different approaches: 

* some companies take a firm line and impose a blocking security gate on SAST warnings;
* other companies take a more lenient approach and do not block development processes with warnings\.  

In the first case, developers hack the system \(for example, they may suppress all warnings, whether they are false or not\), while in the second case, developers may not take the analysis results into account\. 

> Changing people's minds and getting them to be at ease with fixing their code is another matter\.

This raises the question: *do developers care about code security*?

Well, SAST solutions should help development teams improve code security\. Yes, there are drawbacks, such as false positives, but still\. Why do disputes arise? Is the problem in the tools, in the workflows, or both?

**This is where I need your help** — could you share your experience and help me find answers?

Do the development and security teams have any conflicts of interest? How does SAST integrate into the development process? What matters in the SAST tool and what doesn't? Who handles the analysis results, and how it is done?

You are welcome to share your opinions and experiences: tell me more about how these workflows function in your company, what you like and dislike about them, and what may be improved\.
5 Steps to Recover Your Hacked Facebook Account and Keep It Secure
Published: 2023-04-25 12:37:09

Here's a step-by-step guide on how to recover a hacked Facebook account:

**Change your password**

1. Change your password: If you can still log in to your account, change your password immediately. If you can't log in, use the "forgot password" option to reset it.

**Verify your identity**

2. _Verify your identity_: Facebook may ask you to provide a valid ID or take a photo of yourself using your webcam. Follow the instructions provided by Facebook to verify your identity.

**Check your email and phone number**

3. _Check your email and phone number_: Make sure the email and phone number associated with your account haven't been changed. If they have, change them back immediately.

**Use 2FA authentication**

4. _Use two-factor authentication_: Enable two-factor authentication to add an extra layer of security to your account.

**Remove your account from Facebook**

5. _Remove your account from Facebook_: If you've changed your primary email address, remove your account from Facebook to prevent the hacker from accessing it again.

Remember, the most important thing is to keep your password secure and not share it with anyone. Also, be sure to monitor your account for any suspicious activity and report it immediately to Facebook.

_#MlimaVirtual_
Creating Resource group and Virtual machine using Command-line interface (CLI) in Azure
Published: 2023-04-25 12:36:50

Azure command-line interface (Azure CLI) is another way of creating Virtual Machine in Azure apart from PowerShell. Like Azure PowerShell, the Azure CLI is a command-driven scripting environment that also uses the Azure REST API to execute management tasks in Azure. It is nearly identical to Azure PowerShell in capability and function, running on Windows, Linux, and Mac.
Also, as with Azure PowerShell, you can run the Azure CLI in a web browser through the Azure Cloud Shell, giving you the capability to run the Azure CLI in scenarios were running it natively might not be possible or feasible.
Below are the steps to take when using CLI to create Resource group and Virtual machine in Azure.

Login to your Azure portal
After that click on the cloud shell in the Azure porta, then select Bash

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

After clicking on Bash, then you can paste your resource group script to create your Resource group just as shown below

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

From the above image, it shows that resource group has been created which “myCoolRg” and this can also be confirm by clicking on Resource group in Azure portal to see if our resource group has been created. See the image below

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

The next step is to create virtual machine by pasting the script as shown below

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

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

Click on the virtual machine name “myVMcli” to see if it has been created and running.
See the image below 

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

Wow! we have our virtual machine running.
Minimal APIs in .NET
Tags: webdev, csharp
Published: 2023-04-25 12:13:03

The new version of .NET includes a new web framework called "Minimal APIs" that makes it easy to create simple, lightweight APIs, which is .NET 6.

![importent points](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/h1cjpc2tjgd4re280eju.png)

**Here are the steps to create a minimal API using .NET 6:**

- **Create a new project**: Open Visual Studio and create a new .NET 6 project. Choose the "API" template and select the "Minimal API" option.
- **Define endpoints**: Define the endpoints for your API using the MapGet and MapPost methods. The endpoint function should return a response in the desired format (e.g. JSON).

**C-Sharp**

```
var builder = WebApplication.CreateBuilder(args);
var app = builder.Build();
app.MapGet("/", () => "Hello, World!");
app.MapPost("/api/messages", (string message) =>
{
    Console.WriteLine(message);
    return new { status = "success" };
});
```

Run the app: Finally, run the .NET app using the Run method:
```
app.Run();
```

That's it! You've just created a minimal API using .NET 6.

In conclusion,.NET 6's Minimal APIs make it simple to develop straightforward, lightweight APIs. The MapGet and MapPost methods make it simple to specify endpoints and return data in the format you require. By using this strategy, you may maintain the fundamental functionality required by your API while reducing complexity and enhancing performance.
Stop using the terms monolith and microservice
Published: 2023-04-25 12:33:50

---
title: Stop using the terms monolith and microservice
published: true
description: Stop using the terms monolith and microservice and start using the terms distributed and remoting
tags: 
# cover_image: https://direct_url_to_image.jpg
# Use a ratio of 100:42 for best results.
# published_at: 2023-04-25 12:32 +0000
---

Stop using the terms monolith and microservice.

The concepts are distributed vs remoting. You can even setup API’s to do both. And I said can. Not that it should do both.

Martin Fowler is wrong in using monolith. He should say big-ball-of-mud. Linux 1.2a kernel was the last monolith. And the famous debate changed it, to this day, from being one.

gRPC, GraphQL, and message queues/event stores are not microservices. No matter how closely you try to get it to fit. Or even by extending microservices.

These are all remoting

Distributed means a registry like npmjs, nuget, github/gitlab, local, has a copy you pull into your project and use. Or an installer you download.

The question isn’t how remoting and distributed are different. But how are they similar? How are they the same?

It a website needs to do something secure, use remoting.

If functionality needs distributed, use distributed.

If what that otherwise distributed resource needs protected, use remoting.

There is more value in discussing the type of app you are writing:

Is a website too complex?
Should I create a desktop app? At least at first
etc…