teleren/devto huggingface dataset:
Recursion แบบเร็วขึ้นแต่ออกแรงนิดเดียว
Tags: recursion
Published: 2021-06-04 07:47:16

---
title: Recursion แบบเร็วขึ้นแต่ออกแรงนิดเดียว 
published: true
description: 
tags: recursion
//cover_image: https://direct_url_to_image.jpg
---

19 มีนาคม 2562



สมัยที่เรียนหนังสือเขามักจะเอา Fibonacci number มาเป็นตัวอย่างกัน function ก็เป็นงี้ครับ

fib(0) = 0
fib(1) = 1
fib(n) = fib(n-1) + fib(n-2) สำหรับ n มากกว่า 1

ซึ่งเอามาแปลงเป็น Clojure ได้แบบตรงไปตรงมาเลย 

```clojure
(def fib
  (fn [n]
    (if (<= n 1) n
        (+ (fib (- n 1)) (fib (- n 2))))))
```

ผมลองรันบนเครื่องผมใช้เวลา 4.324 วินาที ซึ่งมันช้าเพราะไปเรียก fib ซ้ำไปซ้ำมา ดูง่าย ๆ fib(4) ก็ไปเรียก fib(3), fib(2) แล้ว fib(3) ก็ไปเรียก fib(2) อีกซ้ำ พอเลขมากก็ซ้ำไปเรื่อย ๆ 

จริง ๆ มันมีวิธีหล่อ ๆ เยอะแยะที่จะแก้ปัญหานี้ให้เร็วขึ้น แต่ถ้าเราไม่ต้องหล่อมาแก้แบบดอกเดียวเสร็จก็ใช้ memoize เขียนแบบนี้ 

```clojure
(def fib
  (memoize
   (fn [n]
     (if (<= n 1) n
         (+ (fib (- n 1))
            (fib (- n 2)))))))
(println (time (fib 42)))
```

แก้นิดเดียวเอา memoize มาครอบ function ไว้ มันจะจำ function ที่เคยเรียกไว้แล้วส่งผลกลับมาเลยโดยไม่ต้องไล่ยาว ผลคือโปรแกรมใช้เวลารันเหลือ 0.820 วินาที 

จริง ๆ มันจบแล้วล่ะ แต่เขียนให้ดูอีก function แบบใช้ loop

```clojure
(defn fib [n]
  (loop [i 1 acc0 0 acc1 1]
    (if (< i n)
      (recur (inc i) acc1 (+ acc0 acc1))
      acc1)))      
(println (time (fib 42)))
```

อันนี้ใช้เวลาแค่ 0.0976 วินาที แต่ก็จะเห็นได้ว่าโปรแกรมเปลี่ยนไปเยอะ เปลี่ยนวิธีคิดเยอะ memoize นี่มันแทบไม่ต้องคิดต้องเขียนอะไรมากเลย ใส่ไปแล้วได้ผลเลย

ขอบคุณ visibletrap@twitter.com ที่แนะนำ function time มาครับ
Python filter() function
Tags: python
Published: 2021-06-04 07:46:15

I've recently learned that Python has built-in [global functions like JavaScript](https://daily-dev-tips.com/posts/javascript-filter-method/).
Today we'll be looking into the `filter()` function.

In general, filters are used to filter a [sequence set](https://daily-dev-tips.com/posts/data-types-in-python/#heading-sequence-type-data-type-in-python), for instance, a list.

## Filter() function in Python

Let's first have a look at the syntax:

```python
result = filter(myFunction, input)
```

To give more details to this:

- `result`: Is the output. This will be a filtered sequence. So basically the original input, but without some items
- `filter`: Is the Python built-in function
- `myFunction`: This will be a custom function we are going to build
- `input`: This is the original sequence we want to filter

We'll make a list with numbers. Let's say we want to return only the numbers higher than 10.

```python
input = [2, 11, 3, 23, 105, 1, 9, 10]

def myFunction(n):
    return n > 10

result = filter(myFunction, input)
print(list(result))
# [11, 23, 105]
```

As you can see, our input array includes different numbers. We create a myFunction that serves as the filter function.
There we say return if the number is bigger than 10 include that number.

Then we call the filter on our input and print out our new list returning in:

```text
[11, 23, 105]
```

Already superb, but we can even use [lambda functions](https://daily-dev-tips.com/posts/python-lambda-functions/) to make it easier!

```python
input = [2, 11, 3, 23, 105, 1, 9, 10]

result = filter(lambda n: n > 10, input)
print(list(result))
```

And this will result in the same result.

### Thank you for reading, and let's connect!

Thank you for reading my blog. Feel free to subscribe to my email newsletter and connect on [Facebook](https://www.facebook.com/DailyDevTipsBlog) or [Twitter](https://twitter.com/DailyDevTips1)
Web server กับ process thread และ event loop อย่างสั้น
Tags: web, coding, concurrency
Published: 2021-06-04 07:43:20

---
title: Web server กับ process thread และ event loop อย่างสั้น
published: true
description: 
tags: web,coding,concurrency
//cover_image: https://direct_url_to_image.jpg
---

6 มีนาคม 2562



ผมจะใช้คำศัพท์ thread และ process ในบริบทของ Linux และ *BSD นะครับ ใน OS อื่น ๆ บางตัวเรียกไม่เหมือนกัน

## nginx และ thread pool

* nginx ใช้ event loop ด้วย ใช้หลาย thread ด้วยครับ [1](https://www.nginx.com/blog/thread-pools-boost-performance-9x/) 
* ผมเข้าใจว่าใช้ event loop เดียวรับ request แล้วไปปล่อย task เข้า thread อื่นอีกที แล้วส่งผลคิน event loop

## node.js cluster

* node.js cluster แตก process (แทนที่จะแตก thread) ครับ มี process หลักมา accept incoming connection แล้วส่งต่อให้ process ลูกครับ[2](https://nodejs.org/api/cluster.html) 
* แต่ว่าไม่แน่ใจว่ามี event loop ของแต่ละ process อีกทีหรือเปล่าครับ ผมเดาว่าน่าจะมีแต่ก็ไม่เคยลองดูจริง ๆ ครับ

## Tokio

* [Tokio](https://tokio.rs/) อย่างน้อยจะต่างจาก node cluster ตรงที่ไม่ได้แตก process ครับ แต่ว่าใช้แตก thread ในแง่นี้น่าจะคล้าย nginx มากกว่า node cluster 
* ข้อมูลอีกอย่างคือมี event loop เท่าจำนวน thread ที่แตกออกมาครับ แต่ส่วนนี้ผมยังไม่ได้ดูว่าแบ่งงานกันอย่างไรครับ

## CGI 

ส่วนพวก [CGI](https://en.wikipedia.org/wiki/Common_Gateway_Interface) คือแตก process (_ไม่ใช่_ thread) ทุกครั้งที่มี request ครับ

## PHP

* php-fpm แตก process มารับ request
* mod_php บน Apache ก็แตก process เหมือนกันครับ เพราะว่า php ต้องการแบ่งแยกระดับ process  
* พวกนี้ก็จะทำให้เร็วขึ้นโดยใช้ prefork ไว้ก่อนทำให้เร็วขึ้นได้ 
* ใช้ process pool ไม่ได้ fork หมดเหมือน CGI  แต่ก็เปลือง RAM อยู่ดีครับ
* นอกจากนั้นเพื่อที่จะทำให้เร็วขึ้นมันมี opcache ที่ compile โปรแกรมเก็บไว้ก่อนรับ request อยู่แล้วครับ

## Gunicorn และ Meinheld

gnuicorn ใช้ process มาเป็น worker โดยที่ worker ที่ใช้ meinheld ข้างในก็ไปใช้ picoev เอามาทำ event loop อีกที
เขียนโปรแกรมล้อ pipe ใน shell script
Tags: pipe, shell, functional
Published: 2021-06-04 07:41:23

---
title: เขียนโปรแกรมล้อ pipe ใน shell script
published: true
description: 
tags: pipe,shell,fp
//cover_image: https://direct_url_to_image.jpg
---

5 มีนาคม 2562



ใน shell script มัน pipe ต่อกันไปได้เรื่อย ๆ แบบนี้
 
```shell
cat input.txt | \
      prog1 x | \
      prog2 y | \
      prog3 z
```

* cat อ่านไฟล์ input1.txt แล้วก็ส่งออกมาทาง stdout ต่อมาก็ส่งเข้า prog1 ทาง stdin
* prog1 อ่านข้อมูลจาก stdin ที่ cat ส่งมา; แล้วประมวลผลแล้วก็ส่งออกไป stdout
* prog2 อ่านข้อมูลจาก stdin ที่ prog1 ส่งมา; แล้วประมวลผลแล้วก็ส่งออกไป stdout
* prog3 อ่านข้อมูลจาก stdin ที่ prog2 ส่งมา; แล้วประมวลผลแล้วก็ส่งออกไป stdout
* โดยที่ prog1 prog2 prog3 ก็รับค่า x y z เข้ามาทาง argument ด้วย 

โปรแกรมแบบนี้จะเขียนใหม่เป็น Ruby ก็จะได้ประมาณนี้ หรือจะใช้ Java ก็จะคล้าย ๆ กัน

```ruby
p read_file("input.txt").prog1(:x)
    .prog2(:y)
    .prog3(:z)
```

พวก prog1 prog2 prog3 กลายเป็นชื่อ method ใน object ที่ดูจาก code ก็ไม่รู้ว่า object อะไร หรือกระทั่งตอนรันก็ไม่รู้ว่า prog1 ส่งข้อมูลอะไรออกมา 

ถ้าเป็น shell script ก็ใส่ tee เข้าไปได้เลย

```shell
cat input.txt | \
      prog1 x | \
      prog2 y | \
      tee debug.txt | \
      prog3 z
```
แล้วก็ไปเปิดดูไฟล์ debug.txt ทีหลังได้ โดยที่โปรแกรมโดยรวมก็ยังทำงานปกติ

แต่ถ้าเป็น Ruby หรือ Java ก็จะกลายเป็นท่ายาก เพราะว่าใส่ tee เข้าไปใน object ก็ยากเพราะไม่รู้ว่า object ไหน class อะไร ใส่ไปแล้วจะมั่วหรือเปล่า 

โปรแกรมมันก็จะออกมาประมาณนี้แทน

```ruby
tmp = read_file("input.txt").prog1(:x)
        .prog2(:y)
write_file(tmp)
p tmp.prog3(:z)
```

ถ้าลองเปลี่ยนเป็น Clojure มันก็จะประมาณนี้

```clojure
(-> (slurp "input.txt")
    (prog1 :x)
    (prog2 :y)
    (prog3 :z)
    println)
```

พวก prog1 prog2 prog3 ก็จะเป็นแค่ function ธรรมดาแทนที่จะเป็น method 

นอกจากนั้นก็ยังเขียน tee ขึ้นมาง่าย ๆ ได้แบบนี้

```clojure
(defn tee [data path]
    (spit path data)
    data)
```

แล้วก็เอา tee ไปแทรกได้แบบ shell script 

```clojure
(-> (slurp "input.txt")
    (prog1 :x)
    (prog2 :y)
    (tee "debug.txt")
    (prog3 :z)
    println)
```

โปรแกรมทั้งหมดผมไม่ได้ลองรันจริง ๆ นะครับ อาจจะเจ๊งได้  จาก blog นี้ผมรู้สึกว่าตอบคำถามตัวเองได้ว่าทำไมเวลาเขียน Clojure หรือ Common Lisp ในโปรแกรมที่ค่อนข้างซับซ้อนแล้วรู้สึกสะดวกกว่า Ruby เอาจริงๆ จะเขียน Ruby หรือ Java ให้คล้าย ๆ Clojure ก็คงทำได้ แต่เขียนไปก็จะถูกเรียกว่าไม่ idiomatic อันนี้ก็เป็นอีกเหตุผลนึงให้เปลี่ยนภาษาเพราะว่าภาษามันพ่วงวัฒนธรรมมาด้วย
สรุปประสบการณ์เกี่ยวกับ Rust ต้นค.ศ. 2019
Tags: rust
Published: 2021-06-04 07:39:25

---
title: สรุปประสบการณ์เกี่ยวกับ Rust ต้นค.ศ. 2019
published: true
description: 
tags: rust
//cover_image: https://direct_url_to_image.jpg
---

4 มีนาคม 2562



ผมเคยลองเขียนโปรแกรมจัดการ tree และ alignment ด้วย Rust ทั้งตัว เพราะหวังว่า static type มันน่าจะช่วยหาข้อผิดพลาดได้มาก ผลที่ได้คือผมเสียเวลามากไปกับสิ่งที่เป็นรายละเอียดของ Rust เอง ไม่ใช่ใจความหลักของโปรแกรม แล้วก็มีปัญหาช่วง runtime พอ ๆ กับผมเขียน Ruby เลย สุดท้ายก็ต้องมาเขียน automated tests หรือมา test แบบ manual อยู่ดี แน่นอนว่าผมยังไม่แตกฉาน Rust ก็ได้ แต่ด้วยเหตุอะไรก็ตาม ถ้าต้องเขียนโปรแกรมภาษาแรกที่ผมนึกถึงไม่ใช่ Rust

แต่ถ้าเป็นโปรแกรมทางธุรกิจที่ไม่ได้หลากหลายมาก โครงสร้างข้อมูลนิ่ง ๆ ล้อตาม SQL มาอยู่แล้ว อันนี้ใช้ Rust ก็อาจจะดีก็ได้เพราะว่า struct มันก็ชัดเจนดี บางทีอาจจะพิมพ์ชื่อ field ผิด ลืมใส่บาง field อันนี้มันก็หาให้ได้ แต่แบบหลังนี่ผมยังไม่เคยลอง 

ส่วนที่ใช้ Rust แล้วรู้สึกว่าดีคือเขียนโปรแกรมตัดคำ อันนี้เร็วขึ้นมาก ๆ เร็วขึ้นจากใช้ภาษา dynamic type สัก 10 เท่าได้ เทียบกับพวก Kotlin บน JVM ก็เร็วขึ้นสัก 2 เท่า อันนี้ชัดเจนเลยว่าถ้าอยากได้พวกที่ใช้ CPU เยอะ ๆ แล้วเร็วขึ้นนี่มันได้ผลมาก อีกโปรแกรมที่คล้าย ๆ กันคือเอามาเขียนหาพวก shortest path บน graph อันนี้ก็เร็วอีกเหมือนกัน; อีกงานหนึ่งคือเอาจัดการกฎการแปลที่เป็น tree หลาย ๆ ต้น เอามาสร้างเป็น TRIE เพื่อที่จะทำให้แปลได้เร็ว ๆ อันนี้ก็เขียนออกมาแล้วก็เร็วขึ้นจริง

สิ่งหนึ่งที่ไม่คิดมาก่อนว่ามันจะดีคือ error handling ที่ตรงไปตรงมามาก ถ้าไม่อยากยุ่งอะไรก็ใส่ unwrap() ไปก่อน หรือปล่อยผ่านไปออกเลยก็ใช้ ? เช่น func_do_sth(x)?; ก็คือปล่อยออกไปได้เลยถ้า function ที่หุ้มอยู่มัน return Result ที่ type ใช้กันได้ ท่าแบบนี้มันเขียนน้อย แต่เมื่อไหร่อยากจะกลับมา handle แต่ละจุดให้ดี ๆ ก็แค่ search unwrap กับ ? ใน text editor ก็มาตามอุดได้แล้ว  อันนี้ผมเดาว่าเป็นเหตุให้ desktop app ใหม่ ๆ ที่ใช้ GTK+ ถึงเขียน Rust กันเยอะหรือเปล่า ?

สุดท้ายคือพวก concurrency ข้อดีตามในตำราคือมัน check type ให้ว่า ถ้าอยู่ดี ๆ คือเอาพวก mutable state ไปเที่ยวแชร์กันข้าม thread ไม่ได้ ต้อเอา RWLock หรือ Mutex ไปหุ้มก่อน ถ้าจะตัดปัญหาก็ใช้ channel เอา  แต่สิ่งที่สังเกตได้หลัง ๆ คือ library เช่น library ที่ทำ Web Socket หรือว่า coroutine ของ Rust ส่วนมาก code อ่านรู้เรื่อง แล้วใครอยากจะทำ library แบบไหนก็ทำได้แทบจะตามจิตนาการเลย คล้าย ๆ กับ C เพราะว่าคนที่เขียน Library ขึ้นมาไม่ต้องไปยุ่งกับ Garbage collector ใน runtime เลย เพราะว่ามันไม่มี 😅 ก็ทำให้ตัดเรื่องยุ่งยากหลัก ๆ ออกไปได้เลย และสำหรับผม code มันอ่านง่ายกว่า C
เทคนิคที่ผมเลือกใช้เขียนโปรแกรม
Tags: coding
Published: 2021-06-04 07:38:32

---
title: เทคนิคที่ผมเลือกใช้เขียนโปรแกรม
published: true
description: 
tags: coding
//cover_image: https://direct_url_to_image.jpg
---

4 มีนาคม 2562



แต่ก่อนอยากศึกษา Structured programming, OOP, FP, TDD, design pattern และ programming language ใหม่ ๆ เพราะแต่ก่อนเขียน Pascal นี่ส่วนมากเป็นโปรแกรมแก้โจทย์แบบเขียนคนเดียวไม่เกิน 2 ชั่วโมง ถ้าโครงการใหญ่กว่านั้นล่ม 🥺

ตอนนี้รู้สึกว่าเขียนโปรแกรมได้ใหญ่ยาวหรือซับซ้อนได้เท่าที่ต้องการแล้ว (คนอื่นมาเปิดดูอาจจะรู้สึกว่าไม่ค่อยมีอะไรและมั่ว ๆ 😸 ซึ่งก็อาจจะจริง) 

pattern ที่ลองทำแล้วได้ผลมากคือ

1. มองเป็น data transformation 
2. ใช้ data หลวม ๆ เช่น map หรือ alist 
3. ถ้าใช้ภาษา dynamic ได้ก็ดี 
4. พยายามทำให้โปรแกรมอ่านจากบนลงล่างได้ 
5. พยายามทำให้ function ยาวไม่เกิน 20 บรรทัด (และขึ้นบรรทัดใหม่ตาม style ปกติ)

โปรแกรมที่ผมเขียนส่วนมาเกี่ยวกับ tree แล้วก็มีการโยงกันไปมาระหว่าง tree และ string บางทีก็มี lattice ด้วย ในแต่ละ node พอผ่านแต่ละ function ไปข้อมูลใน node บางทีก็เพิ่มขึ้นเรื่อย ๆ บางทีก็เปลี่ยน string เป็น lattice แล้วเอา lattice ไปเข้าอีก function นึงกลายเป็น lattice ที่เส้นเยอะกว่าเดิม 😛 ผมเคยพยายามจะทำเป็น class หรือ struct แล้วพอว่ามันเปลี่ยนบ่อยมาก

แต่ถ้าทำโปรแกรมคงคลังของธุรกิจเดียวที่ class ก็จะหน้าตาหนี table ใน relational database ไปได้ไม่กี่มากน้อย ข้อ (2) นี่อาจจะไม่จำเป็นก็ได้ (มั้ง) พอเป็น class/struct แล้วบางทีมันก็มีข้อดีว่าช่วยสื่อสารกับคนอื่น ๆ ในทีมได้ แต่โปรแกรมแบบที่ว่าในย่อหน้านี้ผมไม่ค่อยได้ทำไง

การศึกษาภาษาอื่น ๆ เข่น Haskell, Scala, TypeScript ก็อาจจะมีประโยชน์และทำให้ผมสิ่งดี ๆ อื่น ๆ ก็ได้ แต่สำหรับผม ผมมองว่าไม่ใช่เรื่องเร่งด่วน หรือการเรียน design pattern แบบที่ใช้กับ Java หรือ C++ ผมก็มองสำหรับผมรู้ก็ดีแต่ว่าไม่ใช่เรื่องเร่งด่วน

ภาษาที่เรียนใหม่ช่วงนี้แล้วรู้สึกว่ามีประโยชน์คือ Rust เพราะมันเร็ว จริง ๆ C ก็เร็วแต่ผมไม่มีวินัยหรือไม่แม่นพอ เขียน C แล้วบึ้มบ่อยมาก

อีกอย่างที่รู้สึกว่าจำเป็นต้องเรียนคือพวก numpy, MXNet, PyTorch, Tensorflow ส่วนมากเป็น library ที่มันทำให้โปรแกรมเร็วขึ้นโดยที่ไม่ต้องออกแรงมากเลย ใช้ SIMD ด้วยคำสั่งเดียว ทั้งบน CPU, GPU, TPU
Black Friday und Cyber Monday Angebote 2021 - Webmaster Edition
Tags: bloggen, blackfriday, discountsundrabatte
Published: 2021-06-29 11:39:51

---
title: Black Friday und Cyber Monday Angebote 2021 - Webmaster Edition
published: true
date: 2021-06-04 07:38:00 UTC
tags: Bloggen,blackfriday,DiscountsundRabatte
canonical_url: https://bloggerpilot.com/black-friday-cyber-monday/
---

![Black Friday Deals](https://bloggerpilot.com/wp-content/uploads/2020/11/black-friday.png)

 Auch gibt es wieder sehr gute Black Friday und Cyber Monday Angebote für den Webmaster,...
Retrieving MachineGuid on Windows in Rust
Tags: rust, machineguid
Published: 2021-06-04 07:35:33

---
title: Retrieving MachineGuid on Windows in Rust
published: true
description: 
tags: rust,machineguid
//cover_image: https://direct_url_to_image.jpg
---

10 เมษายน 2562

AFAIK  Generating UUID and Xid needs the MachineGuid, so I looked around how to obtain it.

And this is the solution, which I'm not sure if it will work on every Windows machine. 😅

## main.rs

```rust
use winreg::RegKey;
use winreg::enums::*;
use std::io;

fn main() -> io::Result<()> {
    let hklm = RegKey::predef(HKEY_LOCAL_MACHINE);
    let cur_ver = hklm.open_subkey("SOFTWARE\\Microsoft\\Cryptography")?;
    let guid: String = cur_ver.get_value("MachineGuid")?;
    println!("MachineGuid = {}", guid);
    Ok(())
}
```


## Cargo.toml

```toml
[package]
name = "mach_guid"
version = "0.1.0"
authors = ["veer6"]
edition = "2018"

[dependencies]
winreg = "0.6"
```
.emacs + rainbow-delimiter
Tags: emacs, lisp, rainbow
Published: 2021-06-04 07:32:07

---
title: .emacs + rainbow-delimiter
published: true
description: 
tags: emacs,lisp,rainbow
//cover_image: https://direct_url_to_image.jpg
---

26 พฤษภาคม 2562


````Lisp
(custom-set-faces
 ;; custom-set-faces was added by Custom.
 ;; If you edit it by hand, you could mess it up, so be careful.
 ;; Your init file should contain only one such instance.
 ;; If there is more than one, they won't work right.
 '(default ((t (:family "Noto Mono" :foundry "GOOG" :slant normal :weight normal :height 128 :width normal))))
 '(rainbow-delimiters-depth-2-face ((t (:inherit rainbow-delimiters-base-face :foreground "SeaGreen3"))))
 '(rainbow-delimiters-depth-3-face ((t (:inherit rainbow-delimiters-base-face :foreground "DeepPink1"))))
 '(rainbow-delimiters-depth-4-face ((t (:inherit rainbow-delimiters-base-face :foreground "SteelBlue1"))))
 '(rainbow-delimiters-depth-5-face ((t (:inherit rainbow-delimiters-base-face :foreground "orange red"))))
 '(rainbow-delimiters-depth-6-face ((t (:inherit rainbow-delimiters-base-face :foreground "DarkGoldenrod1")))))
````
Customized 502 Bad Gateway Page(Nginx)
Published: 2021-06-04 07:08:15

During the task like database migration, php5-fpm service can be stopped,so that nobody can access the Wordpress site during database maintenance is underway.

###Stop the php5-fpm service

`sudo service php5-fpm stop`

After this accessing the website will show 502 Bad Gateway. We will replace this error with "Under Manintainance Page"

###Configuring and creating custom 502(Bad Gateway)

`sudo nano /etc/nginx/sites-enabled/default`

Add the following config code in port 443 section of Nginx config file which is stated above.
```
        error_page 502 /custom502.html;
        location = /custom502.html {
                root /var/www/html;
                internal;
        }
```

After that create /var/www/html/custom502.html

```
<html>
        <body>
                Site is currently under maintenance. Thank you for your understanding.
        </body>
</html>
```

###Restart the nginx server

`sudo service restart nginx`

After this access the website to see the "Under Maintenance Page" instead of Bad Gateway
Automate Prettier in a pre-commit hook
Tags: tutorial, javascript, typescript
Published: 2021-06-04 06:53:57

[Prettier](https://prettier.io/) is a wonderful tool. It  works in many editors and supports many languages.

But opinionated code formatter is his best feature and the first reason to use it.

When you begin with a new team, the first pain is define the style guide for the project. More the language is permissive, harder is the debate.

With Prettier, debate is closed, because most of the decisions are taken. He has few options, so it's easy to configure. All you need is a json file named `.prettierrc.json`.

That's mine, for example :

```json
{
  "useTabs": false,
  "printWidth": 90,
  "tabWidth": 2,
  "singleQuote": true,
  "jsxBracketSameLine": false
}
```

If you use Visual Studio Code, add the [Prettier extension](https://marketplace.visualstudio.com/items?itemName=esbenp.prettier-vscode) and enable format on save feature. Each time you save a file, Prettier will run and autoformat. It's convenient.

If you don't know what is a pre-commit or a post-commit, they're scripts which execute during the workflow of a commit with git.

All you need is define a precommit file like this one.

```bash
#!/bin/sh
FILES=$(git diff --cached --name-only --diff-filter=ACMR "*.js" "*.ts" "*.tsx" "*.scss" | sed 's| |\\ |g')
[ -z "$FILES" ] && exit 0

# Prettify all selected files
echo "$FILES" | xargs ./node_modules/.bin/prettier --write

# Add back the modified/prettified files to staging
echo "$FILES" | xargs git add

exit 0
```

This file is for a TypeScript project with SCSS, so you can update file extensions to fit yours.

It's run Prettier and add updated files to staging.

And a post commit to update index.

```bash
#!/bin/sh

git update-index -g
```

Create a `.githooks` folder at the root of your project and put a `pre-commit` and  `post-commit` files inside with the content above.

The last commands to type is to tell git the folder of hooks and make them executable. Execute them in your terminal.

```shell
git config core.hooksPath .githooks
chmod +x .githooks/*
```

This post is short but it's everything you need to work with Prettier.

Another tools exists to create hooks, like [Husky](https://typicode.github.io/husky/#/).

Follow me on [Twitter](https://twitter.com/fabienschlegel)
5 Ways to Reverse a String using Python
Tags: python, computerscience, codenewbie, onlinecoding
Published: 2021-06-04 06:51:02


![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/04cdh8l6lcgulubvcect.png)

A string in programming consists of a sequence of literal characters. We use them extensively in almost every program. Hence, it’s important to know them well and be able to use their features as and when the need arises. Reversing a string is an operation that keeps coming up time and again. Here we will see 5 simple ways to reverse a string in Python3. 

#Reverse Indexing
This is a method that is simple but not logical to deduce. It utilizes the start-stop-step indexing on a string to produce the reversed string.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/junycuyp31428tkuseui.png)



#Using Lists
I use this method often. This helps when there are modifications to be made prior to producing a reversed list. Here we convert the string to a list, then use the inbuilt reverse method of the list and join it back into a string.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/svqoia2linf50c3low93.png)


#Reverse Iteration
This is an approach where we step through the string one by one and keep appending the characters to the end of an empty string. At the end, we get a string that is the reverse of our original string.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/uya6s62fogsglu6nm4ts.png)


#Using the Reversed Function
This reversed function is a built-in function in Python3 that allows us to reverse any sequence that is provided. It mainly accesses the sequence in the reverse order. The reversed functions work not only for a string but also for lists, tuples etc.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/9v0etl1w79abp6sdgj9b.png)


#Using Indexing
This is an approach we really need to know as it is the only way we can implement this in other languages like C and C++ etc. Here we just use a loop to iterate from the end to the beginning while appending the characters to an empty string.
![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/jagzdeiwb7gje7f88748.png) 

This article has been written by Suchin Ravi. Suchin is an experienced educator and technologist. Suchin teaches computer science at YoungWonks https://www.youngwonks.com and works as a lead software developer on many projects at Wonksknow https://www.wonksknow.com/.
My First post so just skip this xd
Published: 2021-06-04 06:39:24

Hello,
Namaskar(In Marathi language-Mother tongue),
I have completed my BE in IT in 2018, throughout this entire 6 years which I spent for Diploma and Engineering I never learn a master tip which every knowledge seeker, every student should know at their early stage of life i.e. this courses, syllabus, teachers, colleges, academic marks are not the unit to test your knowledge, to know your internal depth, to explore you from inside. I mean yeah I am not against them but the master tip is feed your soul, mind, brain by yourself no one is going to do that task for you; yes! you need your family, friends, your well wishers but Nature plays very crucial role.

I know, words aren't sorted hahahaha.
see you in the next article.
Har Har mahadev
Handle Exception Error in Laravel using Rescue Helper
Tags: laravel, errors
Published: 2021-06-04 06:33:03

If you want to make your web application robust, you get to handle those quirky and unpredictable exceptions. And the way you do that in PHP is by using try-catch blocks in your code. The same applies in the case of Laravel as well.

#The traditional way

So, for instance, if you want to handle the exception when something goes wrong when saving/updating the model record, you can handle exceptions like so.

public function store(Request $request)
{  
    try   
    {  
        $comment = new BlogComment();  
        $comment->content = $request['comment'];  
        $comment->user_id = Auth::user()->id;  
        $comment->blog_id = $request['ticketId'];  
        $comment->save(); 
    } catch(Exception $e) { 
        if (!($e instanceof SQLException)) {
            app()->make(\App\Exceptions\Handler::class)->report($e); 
            // Report the exception if you don't know what actually caused it
        }
        request()->session()->flash('unsuccessMessage', 'Failed to add comment.');  
        return redirect()->back();
    }
}

As you can tell, we’re using Laravel’s in-built error handling in the catch block to report the exception if it occurs.

Now, this is perfectly fine but do you know there’s a slicker and a cleaner way in Laravel that you can use to make this even shorter. Enter the rescue() helper.

##The rescue() helper

Laravel provided this rescue() helper in which you can pass in the piece of code as a closure for which you want to handle exceptions. The helper will execute the given closure and catches any exceptions that occur during its execution. All exceptions that are caught will be sent to the exception handler.

So, if we want to rewrite the previous example using the rescue() helper, we can do it like so.

[Handle Exception Error in Laravel using Rescue Helper](https://www.codecheef.org/article/easy-way-to-handle-exception-error-in-laravel-using-rescue-helper)

[Fetch HTTP Client Response as Collection in Laravel 8.x](https://www.codecheef.org/article/fetch-http-client-response-as-collection-in-laravel-8x)