DEV Community: Muhammed H. Alkan

What is Monad?

Muhammed H. Alkan — Fri, 05 Apr 2019 18:49:07 +0000

Just, what is monad and why it's used?

Which programming languages do you use and why?

Muhammed H. Alkan — Wed, 23 Jan 2019 19:12:54 +0000

I'm sure there are many people which know around 3 or only 1. Then why did you learnt these programming language(s)?

An alternate way to calculate Fibonacci series

Muhammed H. Alkan — Fri, 18 Jan 2019 18:59:48 +0000

(The alternate way is at the end!)

Fibonacci series is a collection of numbers which two numbers that precede it.

Which will produce a series like this:

0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233, 377

Calculating it

There are two popular ways to do this

Using the normal method (1 + 1 = 2, 1 + 2 = 3, 3 + 2 = 5, ...)
Using the recursive method (Fn = F(n - 1) + F(n - 2) where F1 and F2 is equal to 1)

Implementations in Python will be something like this (Finding first 100 Fibonacci numbers)

Normal method

a, b = 0, 1
for _ in range(100)
  print(a, end=' ')
  a, b = b, a + b

#=> 0 1 1 2 3 5 8 13...

Recursive method

def fib(n):
  if n < 3:
    return 1
  return fib(n - 1) + fib(n - 2)

for n in range(100):
  print(fib(n), end = ' ')

#=> 0 1 1 2 3 5 8 13...

(Not recommended to do it in Python due Tail Call Optimization)

So until now, I haven't seen any other ways. Why not find another way?

There is an interesting fact in Fibonacci numbers. What is the fact?

-> Dividing F(n + 1) with Fn (F(n + 1) / Fn) will approximate the golden ratio! (1.61803399...)

Let us test it!

1, 1, 2, 3, 5, 8, 13, 21, 34...

1 / 1 = 1  
2 / 1 = 2  
3 / 2 = 1.5  
8 / 5 = 1.6  
13 / 8 = 1.62  
21 / 13 = 1.615  
34 / 21 = 1.619  
...

And so on! While numbers getting numbers bigger, the ratio will be more similar to the golden ratio. Then, what we can do with it?

If F(n + 1) / Fn ≈ φ, Fn * φ will be (approximately) equal to F(n + 1) which founds the next fibonacci number!

So, let's implement it in Python!

fib = 1
for _ in range(100):
  print(fib, end=' ')
  fib = round(fib * 1.618)

#=> 1, 1, 2, 3, 5, 8, 13, 21, 34...`

So I multiplied fib with 1.618 which is approximate golden ratio. As I said it will be found next fibonacci number approximately. Then I rounded it because I want an integer, not a decimal. If we need to visualize it:

fib = 1  
fib = round(fib * 1.61) -> fib = round(1.61) -> fib = 2      
fib = round(fib * 1.61) -> fib = round(3.22) -> fib = 3      
fib = round(fib * 1.61) -> fib = round(4.83) -> fib = 5      
fib = round(fib * 1.61) -> fib = round(8.05) -> fib = 8      
...

And so on! It's an interesting method (found by me :p), but it can be wrong for really big numbers. For big numbers, you will need a better approximation of the golden ratio to use it. Because the decimal numbers multiplying with big numbers will create bigger numbers. For example:

1.2345 * 10 = 12.345  
1.2345 * 100 = 123.45  
1.2345 * 1000 = 1234.5  
1.2345 * 10000 = 12345  
1.2345 * 100000 = 123450

So basically I don't recommend this method for big numbers.

Thanks for reading this post!

WRK: A modern HTTP benchmarking tool

Muhammed H. Alkan — Fri, 04 Jan 2019 20:20:43 +0000

wg / wrk

Modern HTTP benchmarking tool

wrk - a HTTP benchmarking tool

wrk is a modern HTTP benchmarking tool capable of generating significant load when run on a single multi-core CPU. It combines a multithreaded design with scalable event notification systems such as epoll and kqueue.

An optional LuaJIT script can perform HTTP request generation, response processing, and custom reporting. Details are available in SCRIPTING and several examples are located in scripts/.

Basic Usage

wrk -t12 -c400 -d30s http://127.0.0.1:8080/index.html

This runs a benchmark for 30 seconds, using 12 threads, and keeping 400 HTTP connections open.

Output:

Running 30s test @ http://127.0.0.1:8080/index.html
  12 threads and 400 connections
  Thread Stats   Avg      Stdev     Max   +/- Stdev
    Latency   635.91us    0.89ms  12.92ms   93.69%
    Req/Sec    56.20k     8.07k   62.00k    86.54%
  22464657 requests in 30.00s, 17.76GB read
Requests/sec: 748868.53
Transfer/sec:    606.33MB

Command Line Options

-c, --connections: total number of HTTP connections to keep open with
                   each thread handling N = connections/threads
-d, --duration:

…

View on GitHub

Nothing to say, it's simple!

Show your editor!

Muhammed H. Alkan — Mon, 24 Dec 2018 17:04:35 +0000

My Neovim is

So clean. I love it!

About dev.to bots

Muhammed H. Alkan — Thu, 22 Nov 2018 12:22:58 +0000

So, firstly there is should be an option to mute "x followed you!" notifications.
They can be are annoying sometimes.

Also, there are bots in dev.to, that does nothing and tries to advertise their own sites. I don't want to dev.to became a dud site.

What is Markov Chain?

Muhammed H. Alkan — Sun, 11 Nov 2018 16:19:07 +0000

So, firstly let's learn what is Markov Chain.

Markov Chain is a stochastic process (random process) of a possible events.
So if you give an information or data, it's possible to change evolution of the events.

Now, let's see how it does work.

For example we have three inputs:

I am Sam.
I am Kevin.
I do

Let's go step-by-step to learn what algorithm does

Building chain

First, we should tokenize our sentence. The output should look like:

["I", "am", "Sam."]
["I", "am", "Kevin."]
["I", "do"]

Secondly, we will start to build our chain. We need to iterate on each tokenized sentence, let's make list to iterate on it:

[["I", "am", "Sam."], ["I", "am", "Kevin."], ["I", "do"]]

While iterating on this list, we should create our chain.
- First sentence, first word: "I"

{
  "I": {

  }
}

As can you see there is only "I" to generate a sentence.
So you will only get output like "I I I I I I"!

First sentence, second word: "am"

{
  "I": {
    "am": 1
  },
  "am": {

  }
}

Because "am" words becomes after "I", we have added it
in "I" node. And 1 becomes for 1 / 1. Because there is
only 1 possibility that can come after "I" word. We have
created another "am" outside "I" for the possible words
that can come after "am".

First sentence, third word: "Sam."

{
  "I": {
    "am": 1
  },
  "am": {
    "Sam.": 1
  },
  "Sam.": {

  }
}

We have added "Sam." to "am" because it comes after "am".
And we created another node outside "am" for possible words
that can come after "Sam.".

Simply, we did same thing we did for "am" before.
And our sentence has ended, continue with other sentence.

Second sentence, first word: "I"
We don't have to do anything because "I" already exists
and it's not in any node.
Second sentence, second word: "am"
Same process with Second sentence, first word.
Second sentence, third word: "Kevin.

{
  "I": {
    "am": 1
  },
  "am": {
    "Sam.": 0.5,
    "Kevin.": 0.5
  },
  "Sam.": {

  },
  "Kevin.": {

  }
}

We have added it to "am" node, but the value is 0.5. Why? Because
there is two possible words that can come, "Sam" and "Kevin.".
So the value should be 1 / 2 = 0.5. And we have created the node
outside "am" as we do for each new node.

Third sentence, first word: "I"
Nothing! Because it exists and not in any node.
Third sentence, second word: "do"

{
  "I": {
    "am": 0.666666667,
    "do": 0.333333333
  },
  "am": {
    "Sam.": 0.5,
    "Kevin.": 0.5
  },
  "Sam.": {

  },
  "Kevin.": {

  },
  "do": {

  }
}

Now, why "am" became 0.666666667 and "do" 0.333333333?
Let's make simple calculations. Now, there is two possible words
after "I", "am" and "do". So the values should be 0.5 to 0.5.
But "am" node has words that can come after it. The count is two so
the value of "am" should be 1 - (1 / (1 + 2)). But "do" does
not have so it will doesn't change the amount. So if "am"'s amount is
1 - (1 / (1 + 2)) = 0.666666667, and as you can guess "do" is
1 - 0.666666667 = 0.333333333.

Creating the sentence

Let's say we want to create 3 word sentence now.
So we will select 3 random words, but they should
which words can be come! Let's start!

Our createn data looks like:

{
  "I": {
    "am": 0.666666667,
    "do": 0.333333333
  },
  "am": {
    "Sam.": 0.5,
    "Kevin.": 0.5
  },
  "Sam.": {

  },
  "Kevin.": {

  }
}

The steps are these:

Select a random node start. Uhmm, our lucky node is... I!

Sentence: I

Get into I node. The possible words are:
- am
- do

Now, let's create list that haves 0.666666667 times am,
and 0.333333333 times do.. Now let's select our lucky node!

Our lucky node is... do! That's a low chance.

Sentence: I do

Get into do node. The possible words are: nothing! What we should do now? Is it end of our sentence? No! Let's select a node randomly again.

Our lucky node is... Kevin.!

Sentence: I do Kevin.

Here's our three words sentence: I do Kevin..
And our algorithm will continue like this.

If we want to count the of all possible sentences:

2^len(data)

So, if our data has 4 unique words, the count will be
2^4 = 16 sentences. That is it!

Thanks for reading!

What is Quicksort

Muhammed H. Alkan — Fri, 02 Nov 2018 14:36:40 +0000

Quicksort is a popular and common sorting algorithm that known to be really efficient. It createn 1959, and published in 1961 by Tony Hoare (He's known for Null reference, Processes and Structured Programming etc. too).

Then, let's get into algorithm. If we need to visualize the algorithm, we can visualize it like this:

How algorithm works:

Check if list is empty or vice versa
If the list is one element return the element,
else, continue to the function.
Select a pivot
Pivot is generally being the first element of list.
But pivot can be any element of list too.
For example:

[b, a, d, e, c], Our pivot is b

Filter the smaller/bigger numbers than pivot (a) Basically, you should iterate on elements of list, and get the bigger numbers than pivot (a). Then, you should do the same thing for the smaller numbers too. For example:

bigger = Filter numbers in [b, a, d, e, c] bigger than a
smaller = Filter numbers in [b, a, d, e, c] smaller than or equal to a

Sort the filtered bigger and smaller numbers and concenate them Now, we will sort (using same algorithm the bigger and smaller numbers to get order in them and concenate it with the pivot (a)

quicksort(smaller) + [a] + quicksort(bigger)

Then we finished our algorithm! Now, let's implement it in Python & OCaml.

I tried to comment Python alot to beginners understand the code.

def quicksort(array):
  if not array: # If list is empty
    return []
  pivot = array[0] # Pivot is the first element of list
  smaller = [n for n in array if n < pivot] # Filter the smaller numbers
  bigger = [n for n in array if n > pivot] # Filter the bigger numbers
  return quicksort(smaller) + [pivot] + quicksort(bigger) # Concenate sorted smaller and sorted bigger with pivot

Now, let's implement it in OCaml!

let rec quicksort list =
    match list with
    | [] -> []
    | pivot :: _ ->
      let smaller = List.filter (fun n -> n < pivot) list in
      let bigger = List.filter (fun n -> n > pivot) list in
      quicksort(smaller) @ [pivot] @ quicksort(bigger)

Let's try to run it in repl

# quicksort [5, 1, 9, 4, 6, 7, 3];;
- : (int * int * int * int * int * int * int) list = [(5, 1, 9, 4, 6, 7, 3)]

It works! (After 18 tries)

And finally, the performance of Quicksort is:

Worst performance: O(n2)
Average performance: O(n log n)
Best performance: O(n log n)

The average and best performance is same.

If we need to visualize the sorted list:

(Special thanks to Learn you a Haskell for great good! for photo. It has really good Haskell chapters!)

In the next posts, i'll share the Quickselect algorithm developed by same person developed Quicksort (Tony Hoare)! Goodbye!

What does Elixir defmodule actually?

Muhammed H. Alkan — Sun, 28 Oct 2018 14:12:01 +0000

I want to know why defmodule exists in Elixir. What does it do actually?

Map vs List comprehension in Python

Muhammed H. Alkan — Sat, 27 Oct 2018 14:55:24 +0000

So, I was trying to learn Elm (I just gave up), then I saw this feature request:

Request: add list comprehensions #147

deadfoxygrandpa posted on May 04, 2013

I suggest that list comprehensions be added to Elm. They see heavy use in languages that implement them. Considering the existing similarities between Elm and Haskell syntax, I propose using Haskell style list comprehensions, like this:

[(x, y) | x <- [1..10], y <- [1..20], x /= y]

View on GitHub

I was trying to find an alternative to list comprehension in Elm, they was recommending to use map. List comprehension is just a Syntactic Sugar. Then let's compare both of them in Python.

Performance

map performance:

lambdef lab λ python -m timeit "map(lambda a: a*a, range(100))"
100000 loops, best of 3: 11.5 usec per loop

List comprehension performance:

lambdef lab λ python -m timeit "[a*a for a in range(100)]"     
100000 loops, best of 3: 5.51 usec per loop

List comprehension is 2x faster!

Syntactical comparison

Actually, List comprehension looks more concise and beautiful than map.
For example:

[n for n in nlist]|
                  |
                  |
map(lambda n: n, nlist)

It's 5 bytes larger and slower! Bad!

Bytecode generation

There is dis to show Python Bytecode of Python code. Let's see the bytecode of list comprehension and map to compare the performance.

Bytecode of [n for n in range(100)] (List comprehension)

  1           0 LOAD_CONST               0 (<code object <listcomp> at 0x7f042c8eac00, file "<dis>", line 1>)
              2 LOAD_CONST               1 ('<listcomp>')
              4 MAKE_FUNCTION            0
              6 LOAD_NAME                0 (range)
              8 LOAD_CONST               2 (100)
             10 CALL_FUNCTION            1
             12 GET_ITER
             14 CALL_FUNCTION            1
             16 RETURN_VALUE

It loads list comprehension, creates function, loads range function and loads 100 to give it as argument, calls range function, and returns the value.

Bytecode of map(lambda n: n, range(100)) (Map)

  1           0 LOAD_NAME                0 (map)
              2 LOAD_CONST               0 (<code object <lambda> at 0x7f042c8ead20, file "<dis>", line 1>)
              4 LOAD_CONST               1 ('<lambda>')
              6 MAKE_FUNCTION            0
              8 LOAD_NAME                1 (range)
             10 LOAD_CONST               2 (100)
             12 CALL_FUNCTION            1
             14 CALL_FUNCTION            2
             16 RETURN_VALUE

It loads map function, it loads the lambda (lambda n: n), makes the lambda function object, loads range function and loads 100 to give it as argument, calls two functions and returns the value.

In my opinion, Python Bytecode is understandable by humans™.

Pros & Cons

List comprehension

Pros
- Support for generating lists directly
- Support for generating generators directly
- Filtering (ifs)
- Concise
- Fast
Cons
- No cons! (IMO)

Map

Pros
- No pros! (IMO)
Cons
- Generates only map object (You need to turn it into the object you want later)
- No ifs (filtering)
- Slower
- Verbose

Code examples

Double each number to 100

# List comprehension
[n*2 for n in range(100)]

# Map
map(lambda n: n*2, range(100))

Apply fn to each number to 100

# List comprehension
[fn(n) for n in range(100)]

# Map
map(fn, range(100))

Filter evens

# List comprehension
[n for n in range(100) if n % 2 == 0]

# Map
not_possible()
# But you can use filter:
# filter(lambda n: n % 2 == 0)

Conclusion

Use list comprehension over map while optimizing your code.

Thanks for reading!

Extend is sometimes faster than Append

Muhammed H. Alkan — Wed, 24 Oct 2018 15:41:29 +0000

I just was comparing the performance difference between [].append(x) and [] + [x]. I just realized [].append(x) was faster. But when i tried it with [].extend([x]) is faster. You just can use it while optimizing your code. Do not use it while you're coding, but when you're going to optimize it use [].extend([x]). Simple benchmarks

>>> import timeit
>>> start = timeit.timeit()
>>> [1, 2, 3, 4] + [5]
[1, 2, 3, 4, 5]
>>> end = timeit.timeit()
>>> end - start
0.006420466001145542
>>> start = timeit.timeit()
>>> [1, 2, 3, 4].append(5)
>>> end = timeit.timeit()
>>> end - start
0.004373588995804312
>>> start = timeit.timeit()
>>> [1, 2, 3, 4].extend([5])
>>> end = timeit.timeit()
>>> end - start
0.0022365170007105917

Results for the first benchmark

Fastest: [1, 2, 3, 4].extend([5])
0.0022365170007105917 seconds

Medium: [1, 2, 3, 4].append(5)
0.004373588995804312 seconds

Slowest: [1, 2, 3, 4] + [5]
0.006420466001145542 seconds

Second benchmarks from CLI

lambdef ~ λ python -mtimeit -s'[1, 2, 3, 4] + [5]'
100000000 loops, best of 3: 0.00939 usec per loop
lambdef ~ λ python -mtimeit -s'[1, 2, 3, 4].append(5)'
100000000 loops, best of 3: 0.00938 usec per loop
lambdef ~ λ python -mtimeit -s'[1, 2, 3, 4].extend([5])'
100000000 loops, best of 3: 0.00993 usec per loop

Results for the second benchmark

Fastest: [1, 2, 3, 4].append(5)
100000000 loops, best of 3: 0.00938 usec per loop

Medium: [1, 2, 3, 4] + [5]
100000000 loops, best of 3: 0.00939 usec per loop

Slowest: [1, 2, 3, 4].extend([5])
100000000 loops, best of 3: 0.00993 usec per loop

So when you add items continuously, you should prefer .append(), otherwise you should use .extend().

What is Functional Programming

Muhammed H. Alkan — Wed, 24 Oct 2018 14:58:19 +0000

Firstly, we should know what is a programming paradigm means.
Programming paradigm is a way to classify programming languages.

Let's see the common programming paradigms include

* imperative in which the programmer instructs the machine how to change its state,
  * procedural which groups instructions into procedures,
  * object-oriented which groups instructions together with the part of the state they operate on,

* declarative in which the programmer merely declares properties of the desired result, but not how to compute it
  * functional in which the desired result is declared as the value of a series of function applications, <- We will learn this
  * logic in which the desired result is declared as the answer to a question about a system of facts and rules,
  * mathematical in which the desired result is declared as the solution of an optimization problem

// https://en.wikipedia.org/wiki/Programming_paradigm

When we will functional in any language you should accept these rules:

DO NOT mutate your data
- You should not change the value of data, or change the data to another variable.
- Use only constants

That means you should disallow side-effects!

// This is not allowed!
let mut something = 20;
something += 7;

// This is allowed.
let something = 20;
let something_else = something + 7;

Each function should return value(s).

// This is not allowed!
fn something() {
  println!("27");
}

// This is allowed.
fn something() -> i32 {
  return 5
}

What ~~will~~ can you use when you ~~purely~~ functional:

Shadowing
- Having 2 different constants in different scopes

let a = 20;
{
  let a = 7;
  println!("{}", a);
}
println("{}", a);

/*
Output:
7
20
*/

Recursion
- You can't use for or foreach loops when you ~~purely~~ functional. Because you're just changing the single variables value. This is not allowed because of immutability. Factorial example

fn fact(n: i32) -> i32 {
  if n == 1 {
    1
  }
  else {
    n * fact(n - 1)
  }
}

/*
fact(5);
5 * fact(4)
5 * 4 * fact(3)
5 * 4 * 3 * fact(2)
5 * 4 * 3 * 2 * fact(1) -> It's 1! Return 1 and stop recursion.
5 * 4 * 3 * 2 * 1
5 * 4 * 3 * 2
5 * 4 * 6
5 * 24
120
*/

Foreach-like example (python example :p)

def double_each(arr):
  if arr == []:
    return []
  return [arr[0] * 2] + double_each(arr[1:])

print(double_each([2, 7, 8]))

"""
double_each([2, 7, 8])
[4] + double_each([7, 8]))
[4] + [14] + double_each([8])
[4] + [14] + [16] + double_each([]) -> Got empty list! Return empty list and stop recursion.
[4] + [14] + [16] + []
[4] + [14] + [16]
[4] + [14, 16]
[4, 14, 16]
"""

Map, Reduce and Filter
- Map: apply function f on each item in list and return a new list.
- Reduce: apply function f to first two items in list and continue like this.
- Filter: Add to new list if f returns true.

Map

>>> list(map(lambda n: n * 2, [2, 7, 8])
[4, 14, 16]

Reduce

>>> from functools import reduce
>>> reduce(lambda a, b: a + b, [2, 7, 8])
17

Filter

>>> list(filter(lambda n: n % 2 == 0, [2, 7, 8]))
[2, 8]

Questions

What is lambda calculus?
Simply, lambda calculus is a theorical framework for describing functions and their evaluation. It forms the basis of almost all current functional programming languages!
Wikipedia
What is the first functional programming language?
LISP! The oldest (after FORTRAN (FORmula TRANslation)) and it's still in usage (For example Clojure). It's based on s-expressions.
What is Purely Functional?
Purely functional means ONLY ALLOW FUNCTIONAL PROGRAMMING RULES. However, you can Purely functional in many languages. Just accept the rules.

Made while listening MU40PROJ.KDM by BUILD Engine creator Ken Silverman

This is my first post, so it's possible to make BIG MISTAKES.