Elliptic Curve Digital Signature Algorithm

Anahtar Uzunluğu
Açıklaması şöyle.

ECC keys can be much shorter than RSA keys, and still provide the same amount of security, in terms of the amount of brute force that an attacker would need to crack these keys. For example, a 224-bit ECC key would require about the same amount of brute force to crack as a 2048-bit RSA key.

IPV6 Adres Çeşitleri

Giriş
IPV6 Adresleri şöyle sınıflanır

1. Documentation
Açıklaması şöyle. Bu adres aralığı yönlendirilebilir (routable) ve erişilebilir değil!

The IPv6 documentation prefix (2001:db8:::/32) must be used ONLY for documentation purposes. It means written examples, diagrams, PPT presentations, Textbook explanations, etc.
This range shouldn't be used in practical networks.

2. Private
Açıklaması şöyle.

There is a "private IP range" of fc00::/7 which should be used for device testing, demos, courses, etc. as per RFC4193

3. Multicast
Tam liste burada. Açıklaması şöyle.

The multicast ranges are 224.0.0.0/4 for IPv4 and ff00::/8 for IPv6.

ffx1::
Örneğin "ff01::". Bu multicast adresi node-local veya interface-local olarak isimlendirilir. Bilgisayar kendi içinde haberleşir.

4. Link Local - İşletim Sistemi Tarafından Atanan Private Adres
İki çeşit Private Adres var. Açıklaması şöyle

But actually, there are two kinds of private addresses: the Unique Local Addresses (ULAs) and the link-local addresses (LLAs).

Link Local Address yazısına taşıdım.

5. Unique Local
Açıklaması şöyle. Mantık olarak IPv4 Private adres ile aynı şey.

The block fd00::/8 is defined for /48 prefixes, formed by setting the forty least-significant bits of the prefix to a randomly generated bit string.

Bu adresler Internet açısından routable değildir. Açıklaması şöyle

These addresses are called Unique Local IPv6 Unicast Addresses and are abbreviated in this document as Local IPv6 addresses. They are not expected to be routable on the global Internet. They are routable inside of a more limited area such as a site. They may also be routed between a limited set of sites.

Açıklaması şöyle. Amacı şirketlerin internete çıkmadan birbirleri ile extranet kurabilmeleri

When companies merge or set up an extranet to communicate, it has proven difficult with IPv4 Private addressing because the companies often use the same or overlapping address space, and that requires the ugly hack of NAT to get around, and that can cause problems and break many protocols.

This was identified as a problem when IPv6 ULA was being developed, and the goal was to allow companies to have non-Internet address space, but to have a very high probability that the space used was unique. This is to try to prevent the problem of merging or communication between companies using non-Internet addressing. IPv6 doesn't have NAT, and the goal of IPv6 is to restore the IP end-to-end connectivity that was lost when NAT became necessary due to the limited number of IPv4 addresses.

The first half of the IPv6 ULA space (fc00::/8) is reserved for assignment by a (yet to be named) global authority, while the second half of the IPv6 ULA space (fd00::/8) was set up so that companies could assign their own addressing with a high probability of uniqueness.

6. IPv4 İçeren IPv6 Adresler
Açıklaması şöyle.

:ffff:192.168.0.1
This is used in software that uses IPv6 sockets even for handling IPv4 connections. That  makes it easier to write software because everything looks like IPv6.
64:ff9b::192.168.0.1
This is the NAT64 well-known-prefix. These addresses are NATed to IPv4 by a NAT64 gateway. It is used to let devices that only have IPv6 reach IPv4 destinations.

Adres Okuma
Örnek
Sunucu socket açarken şöyle yaparız. Tüm IPV6 adreslerimin 4444. portunu dinle anlamına gelir.

[::]:4443

Algoritma Analizi - Big O Nedir?

Giriş
Big O işlenen eleman sayısı arttıkça, gerekli sürenin de ne kadar artacağını gösterir. Yani girdinin niceliği arttıkça algoritmanın ne kadar daha çok vakit aldığını anlamak için kullanırız.  Açıklaması şöyle.

Big-O Notation describes scalability
At its core, Big-O Notation is not a description of how long an algorithm takes to run. Nor is it a description of how many steps, lines of code, or comparisons an algorithm makes. It is most useful when used to describe how an algorithm scales with the number of inputs.

Big O belirtmek için söylenen cümleler şöyledir

The two phrases

- The running time is O(n2)

and

- The running time is at most O(n2)

mean the same thing.

Big O Sonucu

Bu değer her zaman artı bir değerdir. Açıklaması şöyle

running times of algorithms are positive integers

Benchmarking

Açıklaması şöyle. Yani sadece Big O'yu bulmak yeterli değil. Hala benchmarking gerekli.

Reading between the lines, I think you may be misunderstanding Big O analysis as being a replacement for benchmarking. It's not. An engineer still needs to benchmark their code if they want to know how fast it is. And indeed in the real world, an O(n) algorithm might be slower than an O(n2) algorithm on real-world data sets.

Asymptotic Kelimesi

Bazen Big O için yapılan açıklamalarda asymptotic kelimesi kullanılıyor. Asymptotic için açıklama şöyle.

When we look at input sizes large enough to make only the order of growth of the running time relevant, we are studying the asymptotic efficiency of algorithms.That is, we are concerned with how the running time of an algorithm increases with he size of the input in the limit, as the size of the input increases without bound. Usually, an algorithm that is asymptotically more efficient will be the best choice for all but very small inputs.

Az Sayıdaki Eleman İçin Big O
Az sayıdaki eleman için Big O'yu tartışmak anlamsızdır. Örneğin çok kısa bir mesafe, yürüyerek, bisikletle veya arabayla gidilebilir ve gereken süre belki de hepsi için o kadar az fark eder ki , O(1) ya da O(n) olmasının bir önemi kalmaz!

Big O'dan Söz Edilemeyen Durumlar
Sadece "Hello World" yazan bir programın, girdisi yani işlenen eleman sayısı olmadığı için Big O gösteriminden söz edilemez.

Big O notation exists to describe a relationship between the size of the input of a function and the number of operations that need to be performed to compute the result for that input.

Your operation has no input that the output can be related to, so using Big O notation is nonsensical. The time that the operation takes is independent of the inputs of the operation (which is...none). Since there is no relationship between the input and the number of operations performed, you can't use Big O to describe that non-existent relationship

Big O ve Diğer Gösterimler
Big O gösterimi yanında Teta ve Omega gösterimleri de var. Big O ve diğer gösterimler P (Polynomial) algoritmalar için kullanılır. Big O algoritmanın sadece üst sınırını belirtir yani upper bound'u belirtir.

Omega Gösterimi Nedir
Omega alt sınırı yani lower bound'u belirtir. Sembolü şöyledir. At nalı gibidir.

Ω(⋅) is a lower bound

Teta Gösterimi Nedir

Teta algoritmanın alt ve üst sınırını belirtir.

The Theta-notation asymptotically bounds a function from above and below. When we have only an asymptotic upper bound, we use O-notation.

Sembolü şöyledir. O harfinin ortasında yatay bir çizgi var gibidir.

Θ(1)

Asymptotically Optimal Nedir
Bir algoritma özel bir iş/durum için en iyi sonucu veriyorsa Asymptotically Optimal denir.

Big O Karşılaştırması
Aşağıda bazı algoritmaların karşılaştırmaları var.

Big O ve Veri Yapıları
Veri yapılarının Big O değerleri şöyle.

Big O ve Sabitler - Scalar (Sayıl) Value
Big O sabitleri dikkate almaz. Bu yüzden f(n) = n ve g(n) = 10n her zaman O(n) kabul edilirler.

Logaritma olsaydı da sabitler fark yaratmazdı. Matematiksel olarak aynı kabul ediliyorlar ve bu durum algoritmaları karşılaştırmayı kolaylaştırıyor.

Ancak pratik kullanımda an^2 + bn + c gibi bir formülde a, b ve c'nin önemsiz kabul edilmesi doğru olmayabilir. Çünkü 2n^2 ve n^2 şeklinde çalışan iki algoritma arasından n^2'yi tercih etmek gerekir. Yani pratikte sabitler önemli.

Big O ve Veri Yapıları Üzerindeki Farklı İşlemler
Veri yapısına ekleme, silme gibi işlemlerin genellikle maliyetleri farklı değerlerdir. Bu değerlerin en iyi, en kötü ve ortalama maliyetleri de vardır.

O(1) - Constant
O(1) - Constant yazısına taşıdım.

O(log(n)) - Logaritmic
O(log(n) - Logaritmic yazısına taşıdım

O (n) - Linear
O(n) - Linear yazısına taşıdım.

O (n log(k))
Burada k en büyük/küçük k tane elemanı temsil ediyor. Örneğin bir dizideki en büyük 100 elemanı bulmanın maliyeti bu olabilir. En büyük en küçük k tane eleman saklamak için priority queue kullanılır. O (n log(n)) algoritmalara göre maliyeti daha düşüktür.


O(n log(n)) - Quasi Linear
Quasi Linear ismi çok tuhaf.
log (n) n sayısının 2 tabanındaki logaritması anlamına geliyor. Yani n sayısının kaç defa 2'ye bölünebildiği demek. Genel olarak divide and conquer algoritmaları bu karmaşıklığa sahiptir.

Özel olaraksa Quicksort örnek verilebilir. 

Aşağıdaki kod parçasında dıştaki döngü O(n) içteki döngü ise j*=2 yüzünden O(log n). O(n) * O(log n) ise = O (n log(n))

int sum = 0;

for(i = 1; i <= inputSize; i++){
    for(j = i; j < inputSize; j *=2 ){
        printf("The value of sum is %d\n",++sum);
    }
}

O(n2) - İkinci Dereceden Yani Quadratic
O(n^2) - Quadratic yazısına taşıdım

O(n3) - Üçüncü Dereceden Yani Cubic
Matris çarpımı iç içe geçmiş üç döngü içerdiği için üçüncü derecedendir. Açıklamayı burada bulabilirsiniz.

O(n!)
Permütasyon hesaplamalarında bu değeri elde ediyoruz. O(n!) O(n^n)'den yine de daha iyidir. Recursive bir örnek için buraya bakabilirsiniz. Travelling Salesman (gidilmesi gereken noktaların hepsine sadece bir kez uğrayarak maliyeti en düşük şekilde tutarak başlangıca dönmeyi gerektiren problem) probleminin de permütasyon kullandığı için O(n!) olduğu yazılı.

Big O ve İç içe Döngüler
İç içe döngü kullanan aşağıdaki sorunun cevabı burada. Aşağıdaki sorunun cevabı 2n-1

Big O ve Auxilary Storage
Algoritmalar incelenirken sadece time complexity özelliklerine değil aynı zamanda ne kadar hafıza kullandıklarına da bakılabilir. Örneğin Sorting algoritm sayfasında Memory başlığı altında algoritmanın ne kadar hafızaya ihtiyaç duydukları da incelenmiş. 

Quicksort gibi bir algoritma özyinelemeli (recursive) olarak çalışıyorsa ,log(n) stack büyüklüğüne ihtiyaç duyar. Merge sort ise O(n) heap büyüklüğüne ihtiyaç duyabilir.

GoF - Adapter Örüntüsü - Two Way Adapter

Two Way Adapter
Class Adapter örneğinde Adapter sınıfımız sadece Target nesnesi gibi davranabiliyordu. Ancak bazen Adapter nesnesinin hem Target hem de Adaptee gibi davranması gerekebilir. Açıklaması şöyle

Adapters provide access to some behavior in the Adaptee (the behavior required in the ITarget interface), but Adapter objects are not interchangeable with Adaptee objects. They cannot be used where Adaptee objects can because they work on the
implementation of the Adaptee, not its interface. Sometimes we need to have objects that can be transparently ITarget or Adaptee objects. This could be easily achieved if the Adapter inherited both interfaces; however, such multiple inheritance is not possible in C#, so we must look at other solutions.

The two-way adapter addresses the problem of two systems where the characteristics of one system have to be used in the other, and vice versa. An Adapter class is set up to absorb the important common methods of both and to provide adaptations to both. The resulting adapter objects will be acceptable to both sides. Theoretically, this idea can be extended to more than two systems, so we can have multiway adapters, but there are some implementation limitations: without multiple inheritance, we have to insert an interface between each original class and the adapter.

Örnek
Elimizde bir hem Target arayüzü hem de Adaptee arayüzleri ve bunların gerçekleştirimleri olsun

interface IBike {
    void Pedal();
}
class Bike : IBike {
    public void Pedal() {
        Console.WriteLine("Moving my vehicle with my body");
    }
}

interface IMotorcycle {
    void Accelerate();
}
class Motorcycle : IMotorcycle {
    public virtual void Accelerate() {
        Console.WriteLine("Moving my vehicle with a hydrocarbon fuel engine");
    }
}

class ElectricBike : Motorcycle, IBike {
    bool _isAccelerating = false;

    public override void Accelerate() {
        _isAccelerating = true;
        Console.WriteLine("Moving my vehicle with a electric engine");
    }

  public void Pedal() {
    if (!_isAccelerating)
      Console.WriteLine("Moving my vehicle with my body");
    else
      Console.WriteLine("Occupying my body with senseless effort,
        for my vehicle is already moving"); 
  }        
}

Kullanmak için şöyle yaparız.

IMotorcycle motorBike = new Motorcycle();
//That is expected, as IMotorcycle can Accelerate.
motorBike.Accelerate();

IBike newBike = new ElectricBike();
//That too is expected, as IBike can Pedal.
newBike.Pedal();

//Now that´s something new, as IBike cannot Accelerate, 
//but the the ElectricBike adapter can, as it implements both interfaces.
(newBike as IMotorcycle).Accelerate();

Örnek

Elimizde bir Target arayüzü ve gerçekleştirimi olsun.

public interface IAircraft
{
  bool Airborne { get; }
  void TakeOff();
  int Height { get; }
}

// Target
public sealed class Aircraft : IAircraft
{
  
  public void TakeOff()
  {
    ...
  }
  public bool Airborne
  {
    ...
  }
  public int Height
  {
    ...
  }
}

Elimizde bir Adaptee arayüzü ve gerçekleştirimi olsun.

// Adaptee interface
public interface ISeacraft
{
    int Speed { get; }
    void IncreaseRevs();
}
// Adaptee implementation
public class Seacraft : ISeacraft
{
  public virtual void IncreaseRevs()
  {
    ...
  }
  public int Speed
  {
    ...
  }
}

Adapter sınıfımız yine Adaptee sınıfından kalıtır ve Target arayüzünü gerçekleştirir. Şöyle yaparız. Burada farklı olarak Adaptee sınıfının IncreaseRevs() metodunu da override ederek davranışı değiştirir.

// Adapter
public class Seabird : Seacraft, IAircraft
{
    int height = 0;
    // A two-way adapter hides and routes the Target's methods
    // Use Seacraft instructions to implement this one
    public void TakeOff()
    {
        while (!Airborne)
            IncreaseRevs();
    }
    // Routes this straight back to the Aircraft
    public int Height
    {
        get { return height; }
    }

    // This method is common to both Target and Adaptee
    public override void IncreaseRevs()
    {
        base.IncreaseRevs();
        if (Speed > 40)
            height += 100;
    }
    public bool Airborne
    {
        get { return height > 50; }
    }
}

Kullanmak için şöyle yaparız.

IAircraft seabird = new Seabird();
seabird.TakeOff(); // And automatically increases speed
Console.WriteLine("The Seabird took off");
// Two-way adapter: using seacraft instructions on an IAircraft object
// (where they are not in the IAircraft interface)

(seabird as ISeacraft).IncreaseRevs();
(seabird as ISeacraft).IncreaseRevs();