teleren/devto huggingface dataset:
⚖️ Low Code vs. No Code : unleash value while mastering risks ☁️
Tags: lowcode, nocode, cigref, cloud
Published: 2023-01-03 10:02:31

## ❔ About

[Cigref](https://www.cigref.fr/english) recently published a report called : 

> "New Low Code/No Code dev practices : unleash value while keeping risks under control"

[![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/w7p0lo4509cfpv6q1pyt.png)](https://www.cigref.fr/nouvelles-pratiques-de-developpement-low-code-no-code)

In this post, you'll find some remarkable points.

## ℹ️ Remarkable points

- 💰 **Opportunities** : it makes it possible to create apps at a very reduced cost
- 📜 **Guidelines and rules** to maximize success : help document and implement process standardization (decision tree, HR process, document workflow management,...)
- 🍝 **Urbanization** : create a shared responsibility between Information System and end-users

## ⚖️ Low Code vs. No Code

- `No Code`: _suited to prototype, create a MVP just by using ready to use components_
- `Low Code`: _Suited to create apps that last longer but that aren't business critic (workflow, web pages,...)_

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

## 👮 `BUILD` & `RUN` guidelines

- 📜 Setting a dedicated governance is a prerequisite for a good deployment
- ⚖️ Define criteria to choose Low vs. No code solutions
- 💸 Master costs (pay attention to _freemium_)
- 🥇 Put the most successful ones under greater control
- 🏙️ Master urbanization
- 🛑 Explain where autonomy starts and ends
- 🧑‍🤝‍🧑 Get a dedicated entity at the development side
- 📊 Setup clear eligibility criteria : _"How business critic is the app, how many users,..."_, _"How complex is UI/UX"_, _"How long will the app last"_
- 🔙 Reversibility
- 🏬 Use **APIs by consulting API portfolio or Marketplace** 

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


## 🔖 Resources

This post is a very (very) condensed version from the original version.
Hopefully you'll be interested in consulting the whole report which has a very rich set of practices, examples and guidelines.

Find below the original content:

- [Nouvelles pratiques de développement Low Code / No Code : Libérer la valeur en maîtrisant les risques](https://www.cigref.fr/nouvelles-pratiques-de-developpement-low-code-no-code)
- [Cigref activity report](https://www.cigref.fr/wp/wp-content/uploads/2022/05/@Cigref_EN_activity_report_2021.pdf)
Enum : A Fun Way to Improved Code Readability and Quality 🌟🌟🌟
Tags: javascript, react, typescript, webdev
Published: 2023-01-03 09:45:06

Have you ever found yourself working on a project where you're constantly dealing😥 with a bunch of numerical constants that represent some concept or state in your code? If so, then you might have wished for a way to give these constants more meaningful names and make your code more readable and maintainable. Well, guess what? There's a way!🌝 It's called an enum, and it's a language construct in TypeScript that allows you to define a set of named constants.

Imagine you're working on a project for a fancy restaurant. Without enums, your code might look something like this:

```typescript 
function getMealStatus(status: number) {
  if (status === 0) {
    return 'Cooking';
  } else if (status === 1) {
    return 'Ready for pickup';
  } else if (status === 2) {
    return 'Delivered';
  } else {
    return 'Invalid';
  }
}

const mealStatus = getMealStatus(1);
console.log(mealStatus); // 'Ready for pickup'
```
But with enums, your code can be much more descriptive and fun:
```typescript
enum MealStatus {
  Cooking = 0,
  ReadyForPickup = 1,
  Delivered = 2,
  Invalid = 3
}

function getMealStatus(status: MealStatus) {
  switch (status) {
    case MealStatus.Cooking:
      return 'Our chefs are hard at work cooking up a delicious meal for you!';
    case MealStatus.ReadyForPickup:
      return 'Your meal is ready for pickup! Come by and get it while it's hot.';
    case MealStatus.Delivered:
      return 'Your meal has been delivered to your doorstep! Bon appétit!';
    default:
      return 'Something went wrong. Please try again.';
  }
}

const mealStatus = getMealStatus(MealStatus.ReadyForPickup);
console.log(mealStatus); // 'Your meal is ready for pickup! Come by and get it while it's hot.'
 ```
Not only is this code more descriptive and easier to understand, it's also more fun to read and work with. And as an added bonus, enums can help catch mistakes at compile-time, saving you time and preventing bugs in your code.

So next time you're working with TypeScript, try using enums to add some fun and clarity to your code. Your fellow developers will thank you for the clear communication!

    Follow me to learn more on Typescript
 [Twitter](https://twitter.com/OnyemachiTrust?t=-sGSzAMKX96IQGp19x48cw&s=09 )  [LinkedIn](https://www.linkedin.com/in/code-with-onye )
Python 的虛數 j
Tags: python
Published: 2023-01-03 09:56:17

在 Python 中是使用 j 作為虛數單位, 但 j 也可以用來當識別字, 因此使用上要特別注意。

## 一定要加上數量

使用虛數時, j 的前面一定要有數量, 例如, 要計算 1j×1j 就一定要寫成：

```python
>>> 1j * 1j
(-1+0j)
```

數量甚至可以是 0：

```python
>>> 0j
0j
```

如果沒有數量, 只有 j, 就會被當成一般的識別字：

```python
>>> j
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'j' is not defined

name 'j' is not defined
```

## 別用 j 當識別字

當然, 你也可以把 j 真的拿來當識別字使用, 例如：

```python
>>> j = 1j
>>> j
1j
```

只是當然這並不是好作法, 既容易混淆, 也不容易看懂, 所以最好不要這樣做。

## 用括號不嫌煩地把複數括起來

將 j 應用在複數時, 請記得用括號將實部與虛部節合在一起, 避免會當成是一個實數和一個只有虛部的複數, 例如以下就會算出錯誤的結果：

```python
>>> 1+2j.imag
3.0
```

原本想要計算複數 1+2j 的虛部, 結果因為 . 的優先權大於 +, 導致結果變成 1+(2j.imag) 了。如果不嫌麻煩加上括號就不會出錯：

```python
>>> (1+2j).imag
2.0
```
Java Training in Chennai
Tags: javascript, java
Published: 2023-01-03 09:52:28

[Java Training in Chennai](https://intellimindz.com/java-training-in-chennai/) at IntelliMindz Institute the educational path are going to be comprehensive that alter essential ideas like threads, operators, servlets, java array, XML handling, information property, JSP, and exception handling. This educational program can offer active Training with the newest java framework like hibernate, struts, and spring. it's widespread within the net application trade underneath the steerage of skilled java certification professionals.

Learn java from java specialists. This is NO.1 Institute for java training in Chennai Learn from trade specialists with versatile Batch Timings. Enquire Now! Certification Support. period Project. 100% Placement Support. skilled Trainers.
Best Psychological Therapist in Jaipur - Dr. Pakhi Sharma - Quarttz Care
Tags: psychology, psychothearpist, health
Published: 2023-01-03 09:37:13


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

Quarttz Care provides the Best Psychological Therapist in Jaipur with Extensive Experience in Therapeutic work. We aim to assist People to Overcome Depression.
[](https://quarttzcare.com/
Hibernate vs JPA
Tags: java, hibernate, jpa, database
Published: 2023-01-03 09:34:56

Java Persistence API (JPA) and Hibernate are two popular technologies used in the Java ecosystem for object-relational mapping (ORM). While they are often used interchangeably, there are some key differences between the two that developers should understand.

JPA is a specification for ORM in Java, defined by the Java Community Process (JCP). It provides a standard set of APIs and annotations for mapping Java objects to and from a database. JPA is a part of the Java Enterprise Edition (Java EE) platform, and it is designed to be used in enterprise applications.

Hibernate is an open-source Java library that implements the JPA specification. It provides a powerful and flexible way to map Java objects to and from a database, and it is widely used in Java applications. Hibernate offers additional features beyond those provided by the JPA specification, such as support for advanced querying and fetching strategies, and the ability to generate a database schema from Java objects.

One key difference between JPA and Hibernate is that JPA is a specification, while Hibernate is a particular implementation of that specification. This means that JPA defines a set of APIs and annotations that must be implemented by any ORM solution that claims to be compliant with the JPA specification. Hibernate is one such solution, but there are others, such as EclipseLink and Apache OpenJPA.

Another difference between JPA and Hibernate is the level of abstraction they provide. JPA is a higher-level API, which means that it abstracts away many of the details of working with a database. This makes it easier to write code that is independent of the underlying database, but it also means that you have less control over the SQL queries that are generated by the ORM. Hibernate, on the other hand, provides more control over the SQL queries that are generated, but this also means that you need to be more familiar with SQL and the database you are using.

In conclusion, JPA and Hibernate are two popular technologies used in the Java ecosystem for ORM. JPA is a specification that defines a standard set of APIs and annotations for mapping Java objects to and from a database, while Hibernate is a popular implementation of that specification that provides additional features and functionality. Developers should choose between JPA and Hibernate based on the level of abstraction and control they need over the ORM process.



This article was originally posted on devcorner.blog
Front End Development : Easy or Hard
Tags: frontend, webdev, javascript, programming
Published: 2023-01-03 08:56:14

Most of the people thought Front-End Development is easy and anyone can learn within few days or it's Just HTML , CSS etc. 
But Actually it's not !!
**YES IT'S NOT !!**
It's as difficult as learning Back-End Development or any other Top-Notch Technologoies.

So, here are some more specific challenges that front-end developers may face:

**Cross-browser compatibility:** Different web browsers can interpret and display HTML, CSS, and JavaScript in different ways, so front-end developers must ensure that their code works consistently across all major browsers.

**Performance optimization:** Front-end developers must be mindful of how their code impacts the performance of a website, particularly on mobile devices with limited processing power and slower internet connections. This may involve optimizing images, minimizing the use of resource-intensive features, and using performance-enhancing techniques such as lazy loading.

**Responsive design:** With the increasing number of devices and screen sizes that people use to access the web, it's important for websites to be responsive, meaning they should look and function well on any device. This requires front-end developers to have a strong understanding of how to build layouts that adapt to different screen sizes and resolutions.

**Testing and debugging:** YES, testing and Debugging is also cosider as part of Front-End Development. Front-end developers must be able to test their code to ensure that it is working correctly, and they must be able to troubleshoot and fix any issues that may arise. This can be a time-consuming and challenging process, especially when dealing with complex or poorly-written code.

**Keeping up with new technologies:** The field of front-end development is constantly evolving, with new frameworks, libraries, and tools being introduced all the time. Front-end developers must stay up-to-date with these developments in order to remain competitive in their careers.

**Collaborating with other team members:** Front-end development is often a collaborative process, and front-end developers may need to work with designers, back-end developers, project managers, and other stakeholders to build and maintain websites and web applications. Effective communication and collaboration skills are therefore important for front-end developers to possess.

So, finally I would say that It's not Easy. Learning any skill even it is front-end , back-end , blockchain , cloud-computing , AI/ML etc. is not easy each of the skill require time, need hardwork and lot's and lot's of practice.
Golang Generics
Published: 2023-01-03 08:38:55

As an example of a generic function, MapKeys takes a map of any type and returns a slice of its keys. This function has two type parameters - K and V; K has the comparable constraint, meaning that we can compare values of this type with the == and != operators. This is required for map keys in Go. V has the any constraint, meaning that it’s not restricted in any way (any is an alias for interface{}).

We can define methods on generic types just like we do on regular types, but we have to keep the type parameters in place. The type is List[T], not List.


When invoking generic functions, we can often rely on type inference. Note that we don’t have to specify the types for K and V when calling MapKeys - the compiler infers them automatically.


```go
package main

import "fmt"

func MapKeys[K comparable, V any](m map[K]V) []K {
    r := make([]K, 0, len(m))
    for k := range m {
        r = append(r, k)
    }
    return r
}

type List[T any] struct {
    head, tail *element[T]
}

type element[T any] struct {
    next *element[T]
    val  T
}

func (lst *List[T]) Push(v T) {
    if lst.tail == nil {
        lst.head = &element[T]{val: v}
        lst.tail = lst.head
    } else {
        lst.tail.next = &element[T]{val: v}
        lst.tail = lst.tail.next
    }
}

func (lst *List[T]) GetAll() []T {
    var elems []T
    for e := lst.head; e != nil; e = e.next {
        elems = append(elems, e.val)
    }
    return elems
}

func main() {
    var m = map[int]string{1: "2", 2: "4", 4: "8"}

    fmt.Println("keys:", MapKeys(m))

    _ = MapKeys[int, string](m)

    lst := List[int]{}
    lst.Push(10)
    lst.Push(13)
    lst.Push(23)
    fmt.Println("list:", lst.GetAll())
}

```
Why.NET Core Is Better Than.NET Framework
Published: 2023-01-03 08:38:44


**Introduction**
The .NET Framework is the traditional.NET version that is used to run.NET applications on Windows.
.NET Core is a free, open-source, and cross-platform platform for running applications on Windows, macOS, and Linux.

Here are some Reasons Why.NET Core Is Better Than.NET Framework

**Compatibility**
Net Core is more compatible than.NET Framework because the.NET Framework. In contrast, the .NET Core platform allows applications to run on Linux, macOS, and Windows. Net Framework, which allows applications to run only on the Windows OS.

**Focuses on devices**
With the current leverage in technology, it is essential to build applications that focus on different technologies. Net Core is focused on a wide range of domains, including gaming, IoT, AI, cloud computing, single-page applications, and even machine learning.  .NET Framework focuses on the Windows OS.

**Performance and Scalability**
Because they support microservices, the most recent releases of.NET Core (.NET Core 6 and.NET Core 7) place a strong emphasis on improving performance and scalability, whereas.NET Framework is less scalable and performant.

**Source**
The.NET Framework includes some open-source components, whereas.NET Core is open-source and welcomes community contributions.

**Microservices Support **
.NET Core has support for microservices and allows a mix of technologies for each microservice, while microservices cannot be used or deployed in the Net Framework.

**Mobile Development**
Because it is a Windows-only platform, the.NET Framework does not support mobile development, whereas the.NET Core does because it is easily compatible with Xamarin.

**Conclusion**
 NET Core was created from the ground up to be a modular, lightweight, quick, and cross-platform Framework  Applications for mobile, desktop, web, cloud, IoT, machine learning, microservices, games, and more , if the project you are working on requires this technologies .NET Core is a great consideration. However When developing Windows-only applications and applications that use.NET Framework technologies, the.NET Framework should be taken into account.
AZ-304 Exam Dumps [2023] Real For Passing
Published: 2023-01-03 08:37:38

PDF and Software Downloadable
IT-Dumps gives Microsoft Azure certification [AZ-304 Exam Dumps](https://dumpsarena.com/microsoft-dumps/az-304/) PDF and Software variations: PDF layout-- Printable model, print Microsoft Azure certification AZ-304 EXAM DUMPS out and examine the exercise questions everywhere. Software layout-- Simulation model, check yourself like Microsoft Azure certification AZ-304 EXAM DUMPS examination actual check.
[AZ-304 Dumps](https://dumpsarena.com/microsoft-dumps/az-304/) is certainly considered one among assessments that qualify a candidate for the Microsoft Certified: Azure Solutions Architect Expert certificates.
This credential is aimed toward the Cloud DBAs and Cloud Administrators who enforce answers which can be well matched with Microsoft Azure.
These experts’ characteristic withinside the stakeholder advisory roles and translate the commercial enterprise necessities into dependable, steady, and scalable Cloud answers.
[Microsoft AZ-304 Exam Dumps](https://www.linkedin.com/pulse/microsoft-az-304-exam-dumps-become-azure-architect-beta-braindumps/) Before taking the check, you want to have superior know-how and competencies in designing and imposing exceptional answers that paintings on Microsoft Azure.
Add dynamic class in react
Tags: webdev, javascript, react, tutorial
Published: 2023-01-03 08:33:03

Today we gonna see how to add classes dynamically in jsx to change design.

Suppose we have below line of code

-- js
import React from "react";
import "./App.css";



```js
function App() {
const row=[
{status: 'approved'},
{status: 'pending'},
{status: 'approved'},
{status: 'pending'},
]
  return (
    <div className="App">
    <div className='list'>
    {row.map((item) => (
     <span className='listbatch'>
     {item.status}
    </span>
    ))}
    </div>
    </div>
  );
}

export default App;

```

You'll get something like this

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

Now you need just add class in literal and add state of that class

```js
function App() {
const row=[
{status: 'approved'},
{status: 'pending'},
{status: 'approved'},
{status: 'pending'},
]
  return (
    <div className="App">
    <div className='list'>
    {row.map((item) => (
     <span className={`listbatch ${item.status}`}>
     {item.status}
    </span>
    ))}
    </div>
    </div>
  );
}
```



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


Below is the css file
```css
.list{
    display: flex;
    flex-direction: column;
    height: 20vh;
    width: 20vw;
    box-shadow:2px 4px 10px 1px rgba(218,218,218,0.478); 
    border-radius: .5rem;
    position: absolute;
    top: 50%;
    left: 50%;
    transform: translate(0%, -50%);
    padding: 10px;
}

.listbatch{
padding: 5px;
border-radius: 5px;
display: flex;
align-items: center;
justify-content: center;
}

.approved{
background-color: green;
color: white;
}

.pending{
background-color: yellow;
color: black;
}
```
Reasons why you should go into code refactoring today!
Published: 2023-01-03 08:31:13

When you hear the word code refactoring what comes to mind? 
Well think of a car that was manufactured in the 90’s and is transformed to a comfy and smooth, and also great looking lambo that’s just an illustration😂. Refactoring is a systematic process of improving code without creating new functionality that can transform a mess into clean code and simple design.one of the main reason of doing code refactoring is to eliminate dirty code which might be as a result of rushing or short cuts in the code creation process anyways see code refactoring as a way of restructuring the whole process, making the code simple to read, understand and give higher efficiency. So tell me will you stick to The car created in the 90’s or you will preface a Lamborghini truck?
Write Code Faster in React (JSX Autocompletion)
Tags: emmet, jsx, react, autocomplete
Published: 2023-01-03 08:28:17

Hello there, today we will be talking about emmet. For those who are still new to react.js and are struggling to write faster HTML (JSX) code in react.js, this article is for you.

> _We will be making use of VS code._

### What is Emmet?
From Wikipedia:
Emmet is a set of plug-ins for text editors that allow for high-speed coding and editing in HTML, XML, XSLT, and other structured code formats via content assist.

In VS Code, it is already included by default for all HTML and CSS files, but we must make some additional configurations to enable Emmet support for HTML in React. As a result, writing HTML in React (.js) files is significantly quicker and simpler.

1. We navigate to settings by clicking on the gear icon or settings icon on the bottom left corner of our text editor, then selecting the settings option.
![](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/kwog9whrxdl9tgllfoq8.png)

2. We click on an open file icon on the top right corner of our editor.
![](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/3eegn02ia8l1mhtewcps.png)
Which then opens a `settings.json` file.
We then add this block of json code below to the code already there.

```javascript
 "emmet.includeLanguages": {
        "javascript": "javascriptreact"
    }
```
![](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/k1i0fkrtvwq03mpl873u.png)
Now open any component file in React and type `.menu`, and press the tab key and it will auto-complete it to

```react
<div className="menu"></div>
```

## Conclusion
Emmet is unique because it makes HTML typing faster and allows us to build a huge code block using a single statement.
Emmet boosts developer efficiency when it comes to typing in JSX and the developer experience overall.

Please leave a comment below to ask me anything! I’m always happy to talk and help.

Kindly Connect with me on [Twitter](https://twitter.com/davidemaye) and on [Linkedin](https://www.linkedin.com/in/davidemaye/)

Thanks for Reading!!! 😊
Services VS Utils - What is the difference between Services and Utils
Tags: programming, productivity
Published: 2023-01-03 08:26:35

I very often get a question that **What are the Services and Utils in programming?**

In programming, the terms **services** and **utils**  refer to two different types of modular components that can be used in software development.

## Services
Services are typically used to provide some sort of functionality that can be used by other parts of the program. This might include things like 

- Accessing a database.
- Sending an email.
- Making an API call.

Services are often designed to be reusable, meaning that they can be used in multiple different parts of a program without having to be rewritten each time.

## Utils
Utils, on the other hand, are typically small, specialized pieces of code that are used to perform specific tasks. These tasks might include things like 

- Data validation
- Formatting
- Calculations.

Utils are often used to help simplify and organize the code in a program, making it easier to write and maintain.
LoadRunner Training in Chennai
Tags: loadrunner, training, chennai, intellimindz
Published: 2023-01-03 08:06:16

[LoadRunner training in Chennai](https://intellimindz.com/loadrunner-training-in-chennai/
) will offer 100% real-time, practical, and location. Our team of running shoes is assignment Leads and Technical Architects operating in specific MNC’s and could help in real-time projects. We teach on the architecture of LoadRunner, Why VUGEN is Used, styles of VUSER, Settings to be done before recording, types of protocol, unmarried and multiple protocols with stay examples.