Hello, I'm Mateusz Roth. Versatile Software Engineer from ­čçÁ­čç▒­č笭čç║, specialized in JavaScript, TypeScript, Node.js, React. I'm eager to work with Node.js, Python, Golang, serverless or IoT.
Open-minded, friendly person that loves learning.

[DRAFT] OOP - SOLID

Examples with JS code

S - SRP - Single Responsibility Principle

  • class should have just a one purpose - so for example Animal class shouldnÔÇÖt perform logs to different outputs or shouldnÔÇÖt perform a role of database of animals
  • donÔÇÖt:
1
2
3
4
5
class Animal {
constructor(name: string) {}
getAnimalName() {}
saveAnimal(a: Animal) {}
}
  • do:
1
2
3
4
5
6
7
8
class Animal {
constructor(name: string) {}
getAnimalName() {}
}
class AnimalDB {
getAnimal(a: Animal) {}
saveAnimal(a: Animal) {}
}
  • animal class shouldnÔÇÖt be responsible for database management like saving

O - OCP - Open/Closed Principle

  • classes should be open for extensions (new methods) but closed for modifications (donÔÇÖt change method) - IÔÇÖd say, you can change methods but not the contract what they receive and return
  • IÔÇÖd say this role is more about abstraction and use of inheritance, for example by having a base class Animal with method makeSound, which is going to be implemented by child classes Lion or Snake
  • donÔÇÖt:
1
2
3
4
5
6
7
8
9
10
11
12
//...
function AnimalSound(a: Array<Animal>) {
for(int i = 0; i <= a.length; i++) {
if(a[i].name == 'lion')
log('roar');
if(a[i].name == 'mouse')
log('squeak');
if(a[i].name == 'snake')
log('hiss');
}
}
AnimalSound(animals);
  • You see, for every new animal, a new logic is added to the AnimalSound function. This is quite a simple example. When your application grows and becomes complex, you will see that the if statement would be repeated over and over again in the AnimalSound function each time a new animal is added, all over the application. Do instead:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
class Animal {
makeSound();
//...
}
class Lion extends Animal {
makeSound() {
return 'roar';
}
}
class Squirrel extends Animal {
makeSound() {
return 'squeak';
}
}
class Snake extends Animal {
makeSound() {
return 'hiss';
}
}
//...
function AnimalSound(a: Array<Animal>) {
for(int i = 0; i <= a.length; i++) {
log(a[i].makeSound());
}
}
AnimalSound(animals);
  • another example:
1
2
3
4
5
6
7
8
9
10
class Discount {
giveDiscount() {
if (this.customer == "fav") {
return this.price * 0.2;
}
if (this.customer == "vip") {
return this.price * 0.4;
}
}
}
  • do instead:
1
2
3
4
5
6
7
8
9
10
11
class Discount {
giveDiscount() {
return this.price * 0.2;
}
};

class VIPDiscount: Discount {
getDiscount() {
return super.getDiscount() * 2;
}
};

L - LSP - Liskov Substitution Principle

  • if something uses a class, it should be able to use the class and the base class / child class of it
  • sub-class must be substitutable for its super-class
  • PL: nie sprawdzamy typu klasy, wykorzystujemy metody wirtualne i implementujemy je r├│┼╝nie w r├│znych klasach, ale wywo┼éujemy tak samo

I - ISP - Interface Segregation Principle

  • you should write few interfaces instead of a big one interface that contains all the interfaces
  • make fine grained interfaces that are client specific
  • clients should not be forced to depend upon interfaces that they do not use
  • PL: nie tworzymy metod, kt├│rych nie b─Ödziemy mogli zaimplementowa─ç w klasach korzystaj─ůcych z interfejsu, np. przyk┼éad z draw vs drawCircle, drawTriangle

D - DIP - Dependency Inversion Principle

  • you should create new class by placing in the constructor of it the interface of a class that the new class depends on
  • PL: polegamy na interfejsach, nie ich implementacjach - aby mo┼╝na by┼éo podmieni─ç lub zamockowa─ç

[DRAFT] [PL] C# & OOP

Poniższe notatki to głównie skrót i spis pojęć z kursu dostępnego na stronie https://www.plukasiewicz.net/CSharp_dla_poczatkujacych/Ogolnie_o_jezyku i https://www.plukasiewicz.net/Csharp_dla_zaawansowanych/Atrybuty , uzupełniony o inne źródła.

Cechy C#:

  • warunki logiczne (boolean conditions)
  • garbage collector
    • TODO: jak dzia┼éa?
  • standardowe biblioteki
    • TODO: na przyk┼éad jakie?
  • w┼éa┼Ťciwo┼Ťci i zdarzenia (properties, events)
  • delegaty oraz zarz─ůdzanie zdarzeniami (Delegates, Events Management)
  • ┼éatwo┼Ť─ç u┼╝ywania typ├│w generycznych (Generics)
  • kompilacja warunkowa
  • wielow─ůtkowo┼Ť─ç
  • LINQ i wyra┼╝enia lambda (lambda expressions)
  • deklaracje przestrzeni nazw

Cz─Ö┼Ť─ç 1

https://www.plukasiewicz.net/CSharp_dla_poczatkujacych/Ogolnie_o_jezyku

Notatki z C#:

  • g┼é├│wna metoda ca┼éego programu to Main

Podstawowe cz─Ö┼Ťci j─Özyka:

  • instrukcje i wyra┼╝enia
  • komentarze
  • kompilowanie i wykonywanie
  • s┼éowa kluczowe

Typy:

  • typy warto┼Ťciowe (value types) - w tym r├│wnie┼╝ struct
  • typy referencyjne (reference types)
  • typy wska┼║nikowe (pointer types)
  • konwersja niejawna (implicit type conversion)
  • konwersja jawna (explicit type conversion)
  • zmienne, typy integralne (integral types)
  • typy zmiennoprzecinkowe (floating point types)
  • typy dziesi─Ötne (decimal types)
  • typy logiczne (boolean types)
  • typy puste (nullable types)

Stałe i literały:

  • Sta┼ée odnosz─ů si─Ö do warto┼Ťci, kt├│rych program nie mo┼╝e zmienia─ç w trakcie wykonywania. Te sta┼ée warto┼Ťci nazywane s─ů r├│wnie┼╝ litera┼éami. Sta┼ée traktowane s─ů jak zwyk┼ée zmienne z zaznaczeniem, ┼╝e ich warto┼Ťci nie mog─ů by─ç modyfikowane.
  • litera┼éy ca┼ékowite (integer literals)
  • litera┼éy zmiennoprzecinkowe (floating-point literals)
  • litera┼éy znakowe (character literals)
  • litera┼éy ┼éa┼äcuchowe (string literals)

Operatory:

  • operatory arytmetyczne
  • operatory relacyjne
  • operatory logiczne
  • operatory bitowe
  • operatory przypisania
  • r├│┼╝ne inne operatory

Sterowanie:

  • instrukcja warunkowa if
  • instrukcja warunkowa if..else
  • zagnie┼╝d┼╝ona instrukcja warunkowa if
  • instrukcja wyboru switch
  • zagnie┼╝d┼╝ona instrukcja wyboru switch
  • p─Ötla while
  • p─Ötla for
  • p─Ötla do..while
  • polecenie break
  • polecenie continue

Parametry, inne typy i tablice:

  • parametry typu warto┼Ťciowego, referencyjnego, wyj┼Ťciowego
  • typy puste
  • tablice wielowymiarowe
  • tablice postrz─Öpione
  • klasa Array

Klasy:

  • Klasa mo┼╝e dziedziczy─ç z jednej klasy, ale mo┼╝e implementowa─ç wiele interfejs├│w
  • metody klasy (methods)
  • pola klasy (fields)
  • w┼éa┼Ťciwo┼Ťci klasy (properties) - W┼éa┼Ťciwo┼Ťci nie s┼éu┼╝─ů do przechowywania warto┼Ťci. Przy pomocy accesor├│w maj─ů dost─Öp do p├│l, kt├│re reprezentuj─ů.

Class member, np. pole lub metoda

Class members, in C#, are the members of a class that represent the data and behavior of a class.

Class members are members declared in the class and all those (excluding constructors and destructors) declared in all classes in its inheritance hierarchy.

Class members can be of the following types:

  • Constants representing constant values
  • Fields representing variables
  • Methods providing services like calculation or other actions on its members
  • Properties that define the class features and include actions to fetch and modify them
  • Events generated to communicate between different classes /objects
  • Indexers that help in accessing class instances similar to arrays
  • Operators that define semantics when used in expressions with class instances
  • Instance constructors to initialize members of class instances
  • Static constructor to initialize the class itself
  • Destructors to execute actions necessary to be performed before class instances are discarded
  • Types that are local to the class (nested type)

Class members are initialized in constructors which can be overloaded with different signatures. For classes that do not have constructor, a default constructor that initializes the class members (to default values) will be generated.

Source: https://www.techopedia.com/definition/25589/class-members-c-sharp


Dalej o klasach:

  • instancje klasy
  • hermetyzacja/enkapsulacja, inaczej data hiding (or more accurately encapsulation)
  • modyfikatory dost─Öpu w C# jako cz─Ö┼Ť─ç hermetyzacji - public, private, protected, internal, protected internal
  • typy wyliczeniowe enum - warto┼Ťciowy typ danych - warto┼Ťci, kt├│rych nie mo┼╝na dziedziczy─ç oraz przekaza─ç przez dziedzicznie
1
2
3
4
5
6
7
8
9
10
enum DniTygodnia
{
Poniedzialek = 1,
Wtorek,
Sroda,
Czwartek,
Piatek,
Sobota,
Niedziela
}
  • struktury struct - W j─Özyku C# struktura to warto┼Ťciowy typ danych.

Klasy i struktury maj─ů nast─Öpuj─ůce r├│┼╝nice:

  • klasy s─ů typem referencyjnym a struktury typem warto┼Ťciowym;
  • struktury nie wspieraj─ů dziedziczenia;
  • struktury nie mog─ů mie─ç domy┼Ťlnego konstruktora.

Dalej o klasach:

  • konstruktor i destruktor klasy
  • statyczne sk┼éadniki klasy

Sk┼éadniki statyczne mo┼╝emy zdefiniowa─ç za pomoc─ů s┼éowa kluczowego static. Je┼╝eli zadeklarujemy sk┼éadow─ů jako statyczn─ů nie wa┼╝ne jak wiele obiekt├│w klasy utworzymy, istnieje zawsze tylko jedna kopia sk┼éadowej statycznej.

  • klasa statyczna

Mo┼╝emy utworzy─ç statyczn─ů klas─Ö. Klasa taka m├│wi, i┼╝ nie zosta┼éa napisana po to, aby tworzy─ç nowe obiekty. Nawet, gdyby┼Ťmy chcieli utworzy─ç nowy obiekt klasy statycznej kompilator zg┼éosi b┼é─ůd. Mog─ů by─ç wywo┼éane bez tworzenia instancji danej klasy.

  • dziedziczenie - inheritance
  • klasa bazowa i pochodna - base/parent and derived/child class
  • polimorfizm - polymorphism
  • statyczny polimorfizm, tj. przeci─ů┼╝anie metod i przeci─ů┼╝anie operator├│w
  • polimorfizm dynamiczny, czyli klasy abstrakcyjne i metody wirtualne

Polimorfizm dynamiczny jest realizowany za pomoc─ů klas abstrakcyjnych oraz metod wirtualnych. Metoda mo┼╝e mie─ç r├│┼╝ne implementacje dla r├│┼╝nych klas.


Klasa abstrakcyjna. Klasa taka zawiera abstrakcyjne metody, kt├│rych implementacja zale┼╝y od wykorzystania w poszczeg├│lnych klasach pochodnych.

Poni┼╝ej lista zasad, o kt├│rych nale┼╝y pami─Öta─ç, tworz─ůc klasy abstrakcyjne:

  • nie mo┼╝na utworzy─ç instancji klasy abstrakcyjnej;
  • nie mo┼╝na zadeklarowa─ç metody abstrakcyjnej poza klas─ů abstrakcyjn─ů;
  • kiedy klasa opatrzona jest modyfikatorem dost─Öpu sealed nie mo┼╝e by─ç dziedziczona. Dodatkowo, klasa abstrakcyjna nie mo┼╝e by─ç zdefiniowana jako sealed.

  • metody wirtualne

Je┼╝eli masz zdefiniowan─ů metod─Ö w klasie bazowej, ale chcesz, ┼╝eby zosta┼éa zaimplementowana w klasach pochodnych mo┼╝esz do tego celu zastosowa─ç metody wirtualne.

  • interfejsy

Język C# nie obsługuje wielokrotnego dziedziczenia. Klasa może dziedziczyć po jednej klasie bazowej, ale może implementować wiele interfejsów.

Inne cechy C#:

  • przestrzenie nazw
  • dyrektywy preprocesora
  • wyra┼╝enia regularne
  • obs┼éuga wyj─ůtk├│w
  • odczyt i zapis pliku

Cz─Ö┼Ť─ç 2

https://www.plukasiewicz.net/Csharp_dla_zaawansowanych/Atrybuty

Indeksery:

Delegaty:

  • https://www.plukasiewicz.net/Csharp_dla_zaawansowanych/Delegaty
  • Delegaty to referencyjny typ danych, kt├│ry przechowuje referencje do metody.
  • Delegaty z┼éo┼╝one - Delegat z┼éo┼╝ony wywo┼éuje dwa delegaty tak jakby by┼éy z┼é─ůczone. Operacja taka to tzw. multicasting.
  • W JS nie ma typu delegat├│w, przekazujemy funkcje przez referencje do zmiennej.

Zdarzenia:

Kolekcje:

Typy generyczne:

  • https://www.plukasiewicz.net/Csharp_dla_zaawansowanych/Typy_generyczne
  • Typy generyczne pozwalaj─ů na op├│┼║nienie w dostarczeniu specyfikacji typu danych w elementach takich jak klasy czy metody do momentu u┼╝ycia ich w trakcie wykonywania programu. Innymi s┼éowy, typy generyczne pozwalaj─ů na napisanie klasy lub metody, kt├│ra mo┼╝e dzia┼éa─ç z ka┼╝dym typem danych.

Refleksja:

Unsafe code:

Cz─Ö┼Ť─ç 3

Inne materiały i informacje

Implicit Interface Implementation vs Explicit Interface Implementation

  • Implicit: you access the interface methods and properties as if they were part of the class.
1
2
3
4
5
6
7
8
9
10
11
public class Test : ITest
{
public string Id // Generated by Implement Interface
{
get { throw new NotImplementedException(); }
}
}

Test t = new Test();
t.Id; // OK
((ITest)t).Id; // OK
  • Explicit: you can only access methods and properties when treating the class as the implemented interface.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public class Test : ITest
{
string ITest.Id // Generated by Implement Interface Explicitly
{
get { throw new NotImplementedException(); }
}
}

Test t = new Test();
t.Id; // Not OK
((ITest)t).Id; // OK

ITest it = t;
it.Id; // OK

It allows you to implement two interfaces that define the same method. However, if you explicitly implement the interface, the methods can only be accessed when the variable is typed to that explicit interface.

In terms of ÔÇťwhenÔÇŁ you have to implement an interface explicitly, it is when your class already has a method with the same signature as one of the methods of your interface, or when your class implements several interfaces that share methods with the same signatures but incompatible contracts. Source: https://softwareengineering.stackexchange.com/questions/136319/whats-the-difference-between-implementing-an-interface-explicitly-or-implicitly

More about explicit interface implementation: https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/interfaces/explicit-interface-implementation

Casting struct to interface

The fact that a struct can implement an interface is well known and so is the fact that casting a value type into an interface leads to boxing of the value type. This is because methods in interfaces are defined as virtual and to resolve virtual references, vtable (method table) look up is required. Since value types do not have pointers to vtable they are first boxed into a reference type and then the look up happens. https://blogs.msdn.microsoft.com/abhinaba/2005/10/05/c-structs-and-interface/

Po polsku, chodzi o to, ┼╝e kiedy jako struct zaimplementujemy jaki┼Ť interface , to struct b─Ödzie zapakowany w dodatkowy obiekt. Metody wywo┼éywane na instancji tego struct, kt├│ry jest rzutowany na interface , na przyk┼éad:

1
2
3
4
5
6
7
8
Employee employee = new Employee("Cool Guy", 65);
IPromotion p = employee;
Console.WriteLine(employee);
p.promote();
Console.WriteLine(employee);

//Cool Guy (65)
//Cool Guy (65)

modyfikuj─ů warto┼Ťci tego dodatkowego obiektu, a nie w oryginalnym obiekcie employee. Je┼Ťli zmienimy struct na class to nie b─Ödzie tego boxowania, tworzenia dodatkowego obiektu i wszystko b─Ödzie dzia┼éa─ç jak nale┼╝y. Wynika to z tego, ┼╝e:

  • casting a value type into an interface leads to boxing of the value type
  • This is because methods in interfaces are defined as virtual and to resolve virtual references, vtable (method table) look up is required. Since value types do not have pointers to vtable they are first boxed into a reference type and then the look up happens.

wi─Öcej tutaj: https://blogs.msdn.microsoft.com/abhinaba/2005/10/05/c-structs-and-interface/

Deadlocks

  • TODO: jak dochodzi do deadlock├│w?
  • Transaction levels: snapshot, commitread

ASP.NET MVC, ASP.NET Core MVC:

[DRAFT] JavaScript Node.js Scripts

Node.js Scripts

Difference between a node module and a npm package: npm package might be not a single node module but it can consists of many node modules.

How to create a npm package and publish it to NPM

Short instruction to create a new npm package

First login to NPM using npm adduser or npm login command source. Now go to a new project folder and run npm init and create an index.js file with exports object. Then run npm publish, now you can install your package in another project. You can also use npm link to link your package globally.

Release a new version of a npm package

Simply use command npm version <update_type> where <update_type> is one of the semantic versioning release types, patch, minor, or major source.

Node Scripts

Shebang line:

#! /usr/bin/env node

How to build a command line tool with shelljs

http://blog.npmjs.org/post/118810260230/building-a-simple-command-line-tool-with-npm

How to build CLI with commander

https://medium.freecodecamp.org/writing-command-line-applications-in-nodejs-2cf8327eee2