teleren/devto huggingface dataset:
The Most Familiar Stranger - JavaScripts - 型別
Tags: javascript, beginners, chinese
Published: 2023-05-07 05:34:35

[分享記錄檔 YouTube](https://www.youtube.com/watch?v=tsX_E589-6I&list=PLal-nRIQU5sunSCOSeZZEzUrXUXF22gep&index=5)

### 原始型別

在 JavaScript 中，原始型別 (primitive type) 是指不可變 (immutable) 且沒有任何方法 (method) 的資料型別，共有 7 種原始型別，包括：

1. **`number`**：代表數字，包括整數和浮點數。
2. **`string`**：代表字串，用引號 (single quotes 或 double quotes) 包括起來。
3. **`boolean`**：代表布林值，只有兩個值 true 和 false。
4. **`null`**：代表空值，只有一個值 null。
5. **`undefined`**：代表未定義的值，只有一個值 undefined。
6. **`symbol`**：代表唯一的識別符號，是 ES6 引入的新型別。
7. **`BigInt`**：代表數字，可以精確地表示大於 number 最大值 ( 2 的 53 次方 ) 的數字。

<aside>
💡 JS 的原始型別是沒有方法的，因為原始型別的值不可變，調用方法需要在物件上執行操作，而不是值，所以不能直接在原始型別上調用方法。當我們在一些原始型別上調用方法時，JS 會暫時轉為包裹器物件 (Wrapper Object)，完成操作後再轉回原始型別。

</aside>

以下是一些使用原始型別的範例：

```jsx
let num = 123; // number
let str = 'Hello, world!'; // string
let bool = true; // boolean
let n = null; // null
let u = undefined; // undefined
let sym = Symbol('foo'); // symbol
```

原始型別在 JavaScript 中非常常用，因為它們是非常基本的資料型別，且在程式執行時具有很高的效能。

### 型別轉換

有時我們會依需求主動進行變數的型別轉換，例如：

```jsx
let numStr = '123';
let num = parseInt(numStr); // 將字串轉換為整數
console.log(num); // 123

let bool = true;
let num2 = +bool; // 將布林值轉換為數字
console.log(num2); // 1

let str = 'Hello, world!';
let bool2 = Boolean(str); // 將字串轉換為布林值
console.log(bool2); // true
```

但在執行一些運算式時，JavaScript 會自動進行型別轉換，這種轉換被稱為隱式轉換 ( implicit coercion ) 或強制轉換 ( type coercion )。

```jsx
10 + ' Hi';      // '10 Hi'
'7' * '4';       // 28
let n = 1 - 'x'  // n = NaN
```

| 值 | 轉為字串 | 轉為數字 | 轉為 Boolean |
| --- | --- | --- | --- |
| undefined | ‘undefined’ | NaN | false |
| null | ‘null’ | 0 | false |
| true | ‘true’ | 1 |  |
| false | ‘false’ | 0 |  |
| ‘’ |  | 0 | false |
| ‘1.2’ |  | 1.2 | true |
| ‘one’ |  | NaN | true |
| 0 | ‘0’ |  | false |
| -0 | ‘0’ |  | false |
| 1 | ‘1’ |  | true |
| Infinity | ‘Infinity’ |  | true |
| -Infinity | ‘Infinity’ |  | true |
| NaN | ‘NaN’ |  | false |
| {} | toString() | valueOf() | true |
| [] | ‘’ | 0 | true |
| [9] | ‘9’ | 9 | true |
| [’a’] | join() | NaN | true |
| function(){} | toString() | NaN | true |

### 型別比較

JS 會將型別轉為數字 ( valueOf() ) 或字串 ( toString() ) 然後進行比較，假如轉數字不行會嘗試轉字串，反之轉字串不行會嘗試轉數字。

<aside>
💡 Date 型別會優先轉字串，其餘會優先轉數字

</aside>

```jsx
Number([9]);
// => Number('9')，因為 Array 類別的 valueOf() 不會回傳原始值，所以改為嘗試 toString()
// => 9
```
The Most Familiar Stranger - JavaScript - Garbage Collection
Tags: javascript, beginners, chinese
Published: 2023-05-07 05:27:50

[分享記錄檔 YouTube](https://www.youtube.com/watch?v=S2E61e1dvYc&list=PLal-nRIQU5sunSCOSeZZEzUrXUXF22gep&index=4)

JavaScript 會自動分配物件的記憶體位置並在它們不再被使用時清除，清除的這個行為就是 Garbage Collection。

## Memory life cycle

1. 分配記憶體位置
2. 存取記憶體位置
3. 當不再使用時釋放記憶體位置

## Mark-and-Sweep

遍歷記憶體中所有變數，標記那些仍被使用的變數，沒被標記的就是可以回收的垃圾。

garbage collector 會從 root ( in JS is global object ) 出發，找到所有引用根的物件，再找到引用這些物件的物件，以此類推，將找到所有可到達的物件，並找出那些不可到達的物件。
The Most Familiar Stranger - JavaScript - 閉包
Tags: javascript, beginners, chinese
Published: 2023-05-07 05:25:52

[分享記錄檔 YouTube](https://www.youtube.com/watch?v=vTrtOePbaSw&list=PLal-nRIQU5sunSCOSeZZEzUrXUXF22gep&index=2)

根據 [MDN](https://developer.mozilla.org/zh-TW/docs/Web/JavaScript/Closures) 的說法閉包是函式以及該函式被宣告時所在的作用域環境 ( lexical environment ) 的組合

### **語法作用域 ( lexical scoping )**

```jsx
function init() {
	let name = 'John';
	function getName() {
		return name;
	}
	getName();
}

init();   // John
```

getName() 並無定義 name 這個變數，但它可以參考語法作用域的變數，因此能取用到父函式宣告的變數 name，如果父函式沒找到，它可以繼續往上找，一路找到全域變數。global 的 lexical scope 就是 null。

### **閉包 ( Closure )**

```jsx
function init() {
	let name = 'John';
	function getName() {
		return name;
	}
	
	return getName;
}

let doInit = init();
doInit();   // John
```

```jsx
function init() {
	let name = 'John';
	function getName() {
		console.log(name); // 不能在 name 被宣告前使用
		let name = 'Jay';
	}
	
	return getName;
}
```

在函數內部捕獲和保存當前語境中的變數和狀態，並將其留存在函數外部，以便在後續的呼叫中繼續使用，即使當前作用域已經被銷毀了。

### 應用場景

狀態保存

```jsx
function useState(initialState) {
  let state = initialState;

  function getState() {
    return state;
  }

  function setState(updatedState) {
    state = updatedState;
  }
  return [getState, setState];
}

const [count, setCount] = useState(0);

count();   // 0
setCount(1);
count();   // 1
setCount(500);
count();   // 500
```

模擬私有變數

```jsx
function createCounter() {
  let count = 0;
  function counter() {
    count++;
    console.log(count);
  }
  return counter;
}

const counter1 = createCounter();
counter1(); // 1
counter1(); // 2
counter1(); // 3

const counter2 = createCounter();
counter2(); // 1
counter2(); // 2
counter2(); // 3
```

<aside>
⚠️ 閉包是很強大的功能，但過度使用容易造成記憶體流失 (memory leak)

</aside>

    
- 以下程式碼會依序輸出什麼呢？
    
    ```jsx
    function closure() { 
        let counter = 0; 
        return () => { 
            counter++;
            console.log(counter);
        }; 
    }
    
    const counter1 = closure();
    const counter2 = closure();
    
    counter1();
    counter1();
    counter2();
    counter1();
    ```
    
    答案：1, 2, 1, 3
The Most Familiar Stranger - JavaScript - 變數
Tags: javascript, beginners, chinese
Published: 2023-05-07 05:21:30

[分享記錄檔 YouTube](https://www.youtube.com/watch?v=5sBUtlbesoA&list=PLal-nRIQU5sunSCOSeZZEzUrXUXF22gep&index=1&t=11s)

在 JavaScript 內要宣告一個變數我們可以使用 **var**、**let**、**const** 

那他們之間有什麼差異呢?   為什麼我們在實務應用上總是使用 let、const 呢?

### 作用域 ( Scope )

**const**、**let** 是區塊作用域 ( block scope )，**var** 是函式作用域 ( function scope )

```jsx
function test() {
	{
		const x = 10;
	}
	console.log(x); // Uncaught ReferenceError: x is not defined
	{
		let y = 20;
	}
	console.log(y); // Uncaught ReferenceError: y is not defined
	{
		var z = 30;
	}
	console.log(z); // 30
}
console.log(z); // Uncaught ReferenceError: z is not defined
```

### 提升 ( Hoisting )

是一種將變數、函式宣告提升到作用域頂部的行為。不同的是，如果我們沒有宣告就直接使用該變數，**var** 會回傳 undefined，**let**、**const** 會報錯。

```jsx
function test() {
  console.log(a); // undefined
	var a = 10;
}
test();

// 實際上 JS Runtime 會像這樣
// function test() {
//   var a;
//   console.log(a);
//   a = 10;
// }
// test();
```

```jsx
function test() {
  console.log(a); // Uncaught ReferenceError: Cannot access 'a' before initialization
  let a = 10;
}
test();
```

```jsx
function test() {
  console.log(a); // Uncaught ReferenceError: Cannot access 'a' before initialization
  const a = 1;
}
test();
```

<aside>
💡 變數從區塊的一開始到他被初始化之前就是 temporal dead zone

</aside>

### var 有什麼問題?

實務上我們都不去使用 **var**，因為 **var** 的函式作用域、可重複宣告的特性很容易造成開發上的混亂

```jsx
function test() {
	var name = 'John';
	// 200 行複雜程式判斷
	if (true) {
		var name = 'James'; // 重複宣告不會報錯，會意外覆蓋掉原有變數的值
	}
	console.log(`I am ${name}`); 
}
test(); // I am James
```

**let**、**const** 則不能重複宣告

```jsx
let name = 'John';
let name = 'James'; // Uncaught SyntaxError: Identifier 'name' has already been declared
```

### 何時該使用 const ? 何時該使用 let ?

如果該變數不變則使用 const，會變則使用 let。

<aside>
💡 變不變指的是記憶體位置的改變。

</aside>

```jsx
const b = {};
console.log(b) // {}

b.name = 'John';
console.log(b) // {name: 'John'}
```
SQL::Builder - making the complex SQL query manageable in Raku
Tags: rakulang, raku
Published: 2023-05-07 05:00:19

I just released the first version of [SQL::Builder](https://raku.land/zef:avuserow/SQL::Builder), a module to make SQL queries from data structures in Raku.

```raku
my $sql = SQL::Builder.new;
my $built = $sql.from('table').select('table.foo', 'other.bar').join('other', :using<id>).build;
say $built.sql;
# SELECT table.foo, other.bar FROM table JOIN other USING(id)

```
SQL::Builder: You're still basically writing SQL.

There's already other modules out there ([Red](https://raku.land/zef:FCO/Red),  [SQL::Abstract](https://raku.land/zef:avuserow/SQL::Builder), among others), so what does this bring to the ecosystem?

1. Support for complex queries. This module can do nested joins and subselects, while enabling reusable logic.

2. SQL that's close to the metal. An ORM was not a good fit for this project, but generating queries from code is very helpful.

3. Better `WHERE` clause support. It can currently represent any condition in the form of `left op right`, and while optimized for the typical `foo = ?` query, it can safely handle functions and expressions. <br>This syntax is used for `HAVING` and `JOIN ... ON` as well, providing a lot of flexibility. This was easily the part requiring the most thought, and I plan to write more about the design choices here.
4. It's faster, mostly due to returning rows instead of objects and having a simpler interface.

In short, this module is great for queries that are complex, but have some level of variability, like a query that has optional JOINs depending on user input.

What's coming next?

* support for `UPDATE/INSERT/DELETE` statements
* better support for Arrays as values in WHERE clauses
* optional support for actually running the queries, either via `DBIish` or `DB::Pg` (and related modules)
* I'm sure there will be something else as I continue work on my other project that uses this :)

This module won't be for everyone, but I've found it very useful in another project. Any feedback is appreciated, please either leave a comment here, [open an issue on GitHub](https://github.com/avuserow/raku-sql-builder), or find me in `#raku` on `irc.libera.chat`.
Amazon says Micro Services are Rubbish
Tags: microservices, programming, discuss
Published: 2023-05-07 04:51:33

More than a year ago I started on an article series where I wanted to debunk the myths of software development. It had 39 articles, and the name of the series was literally _"Myth busting"_. The purpose with the articles was to go through all superstitious belief systems I had identified amongst software developers during more than 40 years of software development, to _"get things real"_. The 22nd of March 2023 Amazon more or less publicly admitted that I was right all along. You can find some of my _"epic articles"_ below.

* [You should probably fire your Kafka developer](https://dev.to/polterguy/you-should-probably-fire-your-kafka-developer-j9l)
* [DDD is mostly superstitious rubbish](https://dev.to/polterguy/ddd-is-mostly-superstitious-rubbish-hdo)
* [CQRS is Software Development Schizophrenia](https://dev.to/polterguy/cqrs-is-software-development-schizophrenia-301o)
* [Why waterfall is superior to Agile](https://dev.to/polterguy/why-waterfall-is-superior-to-agile-1mjo)
* [OOP a software development psychosis](https://dev.to/polterguy/oop-a-software-development-mass-psychosis-9n4)
* [Design Patterns is a symptom of a sick programming language](https://dev.to/polterguy/design-patterns-is-a-symptom-of-a-sick-programming-language-2hd8)

The series gathered so much negative attention that one of the managers at DEV had to send me a PM on LinkedIn encouraging me to discontinue it - Which I did for the record. Publicly slaughtering every single superstitious assumption amongst the software development community carries a price. However, one of the most prestigious software development teams at Amazon have now publicly admitted more or less that I was right. The team threw out 90% of their existing micro service based code, and re-created their entire platform based upon the idea of KISS, and in the process made it 10x as scalable, 10x more manageable, and 10x more stable. If you read my article series today, you will easily recognise that roughly 50% of my articles are discussing micro service based architecture, either indirectly or directly.

I wish I was a better man, not having the needs to say this out loud, but unfortunately I am not - So I am just going to say it as it is.

> I told you so ...

* Read [Amazon's article here](https://www.primevideotech.com/video-streaming/scaling-up-the-prime-video-audio-video-monitoring-service-and-reducing-costs-by-90)
* 30 million software developers were wrong, and I was right! 😁
An article on Indian Premier League
Tags: ipl, cricket, jiocinema
Published: 2023-05-07 04:36:38

<p>The Indian Premier League (IPL) is a professional Twenty20 cricket league in India that has captured the imagination of cricket fans around the world. Founded in 2008, the league has grown rapidly in popularity, featuring eight teams representing different cities across India.</p>
<figure><img style="max-width: 100%;" src="https://images.unsplash.com/photo-1531415074968-036ba1b575da?crop=entropy&amp;cs=tinysrgb&amp;fit=max&amp;fm=jpg&amp;ixid=Mnw0Mjg1OTN8MHwxfHNlYXJjaHwxfHxjcmlja2V0fGVufDB8MHx8fDE2ODMyMzI4OTc&amp;ixlib=rb-4.0.3&amp;q=80&amp;w=1080">
<figcaption></figcaption>
</figure>
<p>&nbsp;</p>
<blockquote>
<p>The IPL has attracted some of the biggest names in international cricket, with players from all over the world participating in the league. The tournament provides a platform for young and talented cricketers to showcase their skills, and has helped to unearth some of the best young talents in the game.</p>
</blockquote>
<p>The IPL has also generated a massive following, with millions of fans tuning in from around the globe to watch their favorite teams compete. The league has not only revolutionized cricket in India, but has also had a significant impact on the sport globally.</p>
<p>The IPL has been instrumental in popularizing the T20 format of the game, and has influenced other countries to adopt similar leagues. The league has also had a positive impact on the Indian economy, generating significant revenue for the country.</p>
<p>In addition to the cricketing action, the IPL is known for its glitz and glamour, with celebrities and business tycoons flocking to the stadiums to catch the action. The league has become a major social event, with parties, fashion shows, and other entertainment events being organized around the tournament.</p>
<p>Overall, the IPL has transformed the landscape of Indian cricket, providing a platform for young cricketers to showcase their skills, and generating significant revenue for the country. The league has also played a crucial role in popularizing the game of cricket around the world, and has become an integral part of the global cricketing calendar.</p>
An easy way to use a MySQL database in Node.js (Node.js MySQL vs Node.js MySQL + NanoQL)
Tags: mysql, node, database, javascript
Published: 2023-05-07 04:20:08


There are many libraries and frameworks for the Node.js runtime, and among them MySQL has developed its own library for node.js. You can query and manage MySQL database through this library. However, you have to write a lot of code for each request😨:
```js
// Example of creating database in Node.js MySQL
var mysql = require('mysql');

var con = mysql.createConnection({
  host: "localhost",
  user: "yourusername",
  password: "yourpassword"
});

con.connect(function(err) {
  if(err){
     console.log(err.message);
  };
  console.log("Connected!");
  con.query("CREATE DATABASE mydb", function (err, result) {
    if(err){
     console.log(err.message);
    };
    console.log("Database created");
  });
});

```
And it can be confusing to programmers who are just starting to program. Or, if you are working on a big project there is also a possibility that you will end up with a lot of code like this.
But recently a NanoQL library has been developed. The main and purpose of this library is to make it easy to send and manage MySQL queries and execute programs through shortcodes. Now let's create a database in MySQL with NanoQL:
(Quick start and installation NanoQL:)
```
npm install nanoql
```
```js
// Example of creating database
var Nanoql = require("nanoql");

var con = new Nanoql(["localhost", "yourusername", "yourpassword"]);
console.log("Connected!");

con.sql(`CREATE DATABASE mydb`, (err, res)=>{
   con.isErr(err);
   console.log("Database created");
});
```
Now let's look at other examples:
```js
// Creating table in Node.js MySQL
var mysql = require('mysql');

var con = mysql.createConnection({
  host: "localhost",
  user: "yourusername",
  password: "yourpassword",
  database: "mydb"
});

con.connect(function(err) {
  if(err){
     console.log(err.message);
  };
  console.log("Connected!");
  var sql = "CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))";
  con.query(sql, function (err, result) {
    if(err){
     console.log(err.message);
    };
    console.log("Table created");
  });
});
```
```js
// Creating table in Node.js MySQL + NanoQL
var Nanoql = require("nanoql");

var con = new Nanoql(["localhost", "yourusername", "yourpassword", "mydb"]);
console.log("Connected!");

con.sql(`CREATE TABLE customers (name VARCHAR(255), address VARCHAR(255))`, (err, res)=>{
   con.isErr(err);
   console.log("Table created");
});
```
If you want to save time using MySQL and want to program in easy ways, I recommend NanoQL.
Introducing An Electron scaffold with hot reloading feature!
Tags: electron, react, vue, template
Published: 2023-05-07 04:17:45

# [create-electron-webpack](https://github.com/sprout2000/create-electron-webpack)

## :rocket: Getting Started

```sh
npm create electron-webpack
```

![just run npm create webpack](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/eyq9vyjno252pbf3th8a.gif)

You can also directly specify the project name, the template, and the package manager you want to use via additional command line options.

For example, to scaffold a React + TypeScript project, run:

```sh
# in the case of npm 7+, extra double-dash is needed:
npm create electron-webpack myapp -- --template react-ts
```

_or if you prefer Yarn:_

```sh
yarn create electron-webpack your_app -t vue -m yarn
```

_NOTE: If the arguments are missing or invalid, the command will fall back to interactive mode._

## :thumbsup: Features

- Supports hot reloading in both the main and renderer processes.
- Available in [10 flavors](https://github.com/sprout2000/create-electron-webpack#templates).
- No complicated pre-made settings.

The template provided by this scaffold is _NOT_ an all-in-one. It provides only the necessary and sufficient settings so that you can customize it as you like. In other words, it has no _"eject"_.

## :green_book: API

### Templates

| JavaScript |  TypeScript  |
| :--------: | :----------: |
| `vanilla`  | `vanilla-ts` |
|  `react`   |  `react-ts`  |
|   `vue`    |   `vue-ts`   |
|  `svelte`  | `svelte-ts`  |
|  `preact`  | `preact-ts`  |

### Command line options

| option             | description                                                |
| :----------------- | :--------------------------------------------------------- |
| `--template`, `-t` | Select a template **(_required_)**                         |
| `--manager`, `-m`  | Select a package manager: `npm`(_default_), `pnpm`, `yarn` |

## :hammer_and_wrench: Usage

```sh
# on development with hot reloading
% npm run dev

# on production
% npm run build
```

## :camera_flash: Screen shots

### Hot reloading in renderer process

![hot reloading in renderer process](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/7dz3n5psih1tg5s1xo4n.gif)

### Hot reloading in main process

![hot reloading in main process](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hgzts1eogo2ud3vpt3f0.gif)
Improve OSS issue management with GitHub Issue/Discussion template and actions
Published: 2023-05-07 04:03:39

In this post, I describe how I improved some OSS's issue management.

e.g. https://github.com/suzuki-shunsuke/tfcmt/pull/764

## Enforce users to use Discussion instead of Issue

I set up GitHub Actions to close issues created by users automatically.

e.g. https://github.com/suzuki-shunsuke/tfcmt/blob/4a164485908ee216cd9534900dea82e652c00b38/.github/workflows/close-issue.yaml

![image](https://user-images.githubusercontent.com/13323303/236376582-547f36e9-316c-4ee4-b79d-3dc972550611.png)

Users have to use GitHub Discussions instead. Only maintainers can create issues. This keeps issues maintainable and actionable.

In many projects, the distinction between the use of Issue and Discussion is ambiguous and varies from person to person.
This ambiguousness often raises friction and frustration.
By enforcing users to use Discussion, the ambiguousness would be solved.

Before creating an issue, users would be able to understand the rule by issue template's warning.
By disabling blank issues, users can't ignore templates.

e.g. https://github.com/suzuki-shunsuke/tfcmt/issues/new/choose

![image](https://user-images.githubusercontent.com/13323303/236655501-45979c69-de5a-4f8b-8cbb-d389f857b57e.png)

And the header of issue templates guides this rule to users.

![image](https://user-images.githubusercontent.com/13323303/236655545-e159ff22-7e62-48bd-b718-9c6484ff1b48.png)

## Discussion template

I provide various templates for various use cases.

e.g. https://github.com/suzuki-shunsuke/tfcmt/discussions/new/choose

![image](https://user-images.githubusercontent.com/13323303/236655869-8a8d2306-8d25-4f20-97e4-c71471cf9ca4.png)

If the type of categories isn't enough, users would not be able to choose appropriate category and use general purpose category which isn't well-formatted.

And GitHub's form schema enforces users to write required information and the schema unifies the format of discussions.
This would improve the quality of discussions.
This reduces the miscommunication, the communication to ask required information, and the burden of maintainers.

e.g. https://github.com/suzuki-shunsuke/tfcmt/discussions/new?category=bug-report

![image](https://user-images.githubusercontent.com/13323303/236656006-37b89e9e-d27b-4854-85f9-d68aaf24498b.png)

The non structured category is also provided for general purpose, but the template header encourage users to use other categories.

![image](https://user-images.githubusercontent.com/13323303/236656163-b9d58fd9-b104-4c2f-8717-21751ffeae43.png)

All categories are `Answers enabled`, so we can make the conclusion easy to understand and clarify the status without closing the discussion.
53 berufliches Vorwärtskommen: Wie sieht eine klare Rollenverteilung in Software-Entwicklungsprojekten aus?
Tags: deutsch, career, discuss, management
Published: 2023-05-07 04:03:00

Moin Moin,

> MultiTasking ist gestörte Aufmerksamkeit. (1)

Die Rede ist hier von Aufgabenbereichen bei denen ein Zusammenhangswechsel ( context switch ) bewusst durchgeführt werden muss.

Folglich ist es sinnvoll für die Annehmlichkeit des Entwicklers und für die zielführende Bearbeitung von Aufgaben innerhalb eines Projekts, die Rollen klar zu verteilen.
Hier ein Beispiel aus „Expert PHP and MySQL“ Seite 15 von Marc Rochkind:

1. Datenbankgestaltung und Umsetzung
2. CRUD-Seiten
3. Anwendungslogik ( „e.g. scheduling supermarket checkers, routing deliveries, computing invoices” )
4. Berichte und sonstige Ausgaben
5. (Daten-)Umwandlung ( Altsystem → Neusystem )
6. Systemprüfung
7. Dokumentation
8. Einarbeitung der Anwender

Angenommen an diesem Projekt, arbeiten drei Entwickler A, B und C. Diese könnten sich für die Projektdauer die Rollen wie folgt aufteilen:
A: Datenbank, Berichte und Datenumwandlung
B: CRUD-Seiten und Anwendungslogik
C: Systemprüfung, Dokumentation und Training

1) Wie bewertest du diesen Ansatz ( 5-Sterne-Maß )? 
Ausführungen willkommen.
2) Meinst du, dass wir diesen Ansatz vermehrt in IT-Projekten benötigen ( 5-Sterne- Maß )? 
Ausführungen willkommen.

Lass uns mittels Kommentaren austauschen.

Beste Grüße,
Mustafa

Austausch mittels E-Mail: mustafa.kevin.dwenger@posteo.de
Betreff: Austausch

(1) Entweder ein Schluss von mir oder ein Zitat. Komme nicht drauf.
(2) Siehe auch: [Multitasking doesn’t work — here’s what does.↗](https://asana.com/resources/multitasking)