Jakie są argumenty za słabym pisaniem na klawiaturze?

Stało się to podczas dyskusji z przyjacielem i ciężko mi było wymyślić jakieś dobre argumenty. Jakie korzyści przynoszą słabe pisanie?

Problemem w tego rodzaju dyskusji jest po prostu to, że terminy „słabe pisanie” i „mocne pisanie” są niezdefiniowane, w przeciwieństwie do na przykład terminów „pisanie statyczne”, „pisanie dynamiczne”, „pisanie jawne”, „pisanie niejawne”, „ typowanie „kaczych”, „typowanie strukturalne” lub „typowanie typowe”. Heck, nawet terminy „pisanie manifestów” i „pisanie ukryte”, które są nadal otwartymi obszarami badań i dyskusji, są prawdopodobnie lepiej zdefiniowane.

Tak więc, dopóki twój przyjaciel nie zdefiniuje terminu „słabe pisanie”, który jest wystarczająco stabilny, aby służyć jako podstawa dyskusji, nie ma nawet sensu odpowiadać na to pytanie.

Niestety, poza odpowiedzią Nicka , żaden z ankieterów nie zadał sobie trudu, by podać swoją definicję, i widać zamieszanie, które generuje niektóre komentarze. Trudno powiedzieć, ponieważ nikt tak naprawdę nie podaje ich definicji, ale myślę, że liczę co najmniej trzy różne, tylko na tej stronie.

Niektóre z najczęściej używanych definicji to (i tak, wiem, że prawie żadna z nich nie ma żadnego sensu, ale są to definicje, których ludzie faktycznie używają):

• słabe pisanie = niebezpieczne pisanie / mocne pisanie = bezpieczne pisanie
• słabe pisanie = dynamiczne pisanie / mocne pisanie = pisanie statyczne
• słabe pisanie = pisanie kaczek / mocne pisanie = pisanie nominalne
• słabe pisanie = pisanie strukturalne / mocne pisanie = pisanie nominalne
• słabe pisanie = niejawne pisanie / mocne pisanie = pisanie wyraźne
• słabe pisanie = ukryte pisanie / mocne pisanie = pisanie manifestów
• słabe pisanie = brak pisania / mocne pisanie = pisanie
• słabe pisanie = niejawne rzutowania / mocne pisanie = tylko jawne rzutowania
• słabe pisanie = niejawne lub jawne rzutowania / silne pisanie = brak rzutów w ogóle
• słabe pisanie = niejawne konwersje / mocne pisanie = tylko jawne konwersje
• słabe pisanie = niejawne lub jawne konwersje / mocne pisanie = w ogóle żadnych konwersji
• słabe pisanie = interpretacja / mocne pisanie = kompilacja
• słabe pisanie = wolne / mocne pisanie = szybkie
• słabe pisanie = odśmiecanie / silne pisanie = ręczne zarządzanie pamięcią
• słabe pisanie = ręczne zarządzanie pamięcią / mocne pisanie = odśmiecanie
• … i wiele innych

Trzy definicje, które wydają się być używane najbardziej powszechnie są jednak

• słabe pisanie = twój głupi gówniany język programowania / mocne pisanie = mój super niesamowity język programowania
• słabe pisanie = każdy inny język programowania / mocne pisanie = jedyny język programowania, na którym miałem ochotę się uczyć (zwykle Java, C # lub C ++; dziwnie, ludzie, którzy uczą się np. Haskell lub Scheme jako swojego pierwszego i jedynego języka nie wydają się dzielić ten światopogląd)
• słabe pisanie = każdy język, którego nie rozumiem / mocne pisanie = Java (zamień na C # lub C ++ do woli)

Chyba że wszyscy zgadzają się na definicji tego, co „słaby wpisując” nawet jest , to nie ma sensu myśleć o tym, co może mieć swoje zalety. Zalety czego? Co gorsza, jeśli nie ma definicji w ogóle , to każdy może po prostu przesunąć ich definicje w celu dopasowania ich argumentów, a każda dyskusja jest dość dużo gwarancją, ponosi w flamewar.

Przez lata osobiście kilkakrotnie zmieniałem własną definicję i doszedłem do punktu, w którym nawet nie uważam, by te terminy były już przydatne. Kiedyś myślałem, że słabe pisanie (w różnych definicjach) ma swoje miejsce w skryptach powłoki, ale ilekroć muszę rozwiązać ten sam problem w Bash i PowerShell, boleśnie przypomina mi się, jak się myliłem.

Pamiętaj, że istnieją dwa główne pojęcia, które są często mylone:

Pisanie dynamiczne

Mówi się, że język programowania jest dynamicznie typowany, gdy większość jego sprawdzania typów jest wykonywana w czasie wykonywania, a nie w czasie kompilacji. W typowaniu dynamicznym wartości mają typy, ale zmienne nie; to znaczy zmienna może odnosić się do wartości dowolnego typu.

Zalety tutaj są często odrzucane tylko dla „nowych” programistów, ale mogą być również wygodne dla każdego programisty:

if (!(arr is Array)) arr = [arr]; // is, instanceof, .constructor ==, whatever

Mniej kodu w każdym przypadku, w którym w innym przypadku konieczne byłoby przesłanie lub przypisanie nowej wartości:

if (data is Array)) {
    i = data.length; // no i = ((Array)data).length or Array myArr=(Array)data;
}

Luźne lub słabe pisanie

Słabe pisanie oznacza, że ​​język domyślnie konwertuje (lub rzutuje) typy, gdy są używane.

Korzyści:

• Przekaż dowolną wartość typu jako parametr do funkcji . Przydatny w przypadku wywołań zwrotnych, elastycznych interfejsów API i ułatwia implementację zamknięć.

• Niejawna ocena logiczna . Każdy typ może być oceniony jako wartość logiczna. Ma to również zalety uboczne, takie jak część zmiennej, ||której można użyć w przypisaniu bez konwersji na wartość logiczną:

  var a = param || defaultValue;
  

• Ponownie mniej kodu:

  var num = 5;
  var str = "Hello";
  input.innerHTML = input.value = num;
  for (var i=0; i < input.value; i++) { ... }
  

  Nawet Java musiała odejść częściowo, z niejawnym wezwaniem do .toString()łączenia obiektów z String; w przeciwnym razie programiści Java przeklinaliby to przez cały dzień (instrukcje dziennika byłyby poza kontrolą).

^{Obie definicje pochodzą z http://en.wikipedia.org/wiki/Type_system . Powiedział to lepiej niż ja.}

Głównym argumentem za słabym pisaniem jest wydajność. (aby odpowiedzieć na pytanie PO, jak podano). Istnieje wiele dobrych dyskusji na temat dynamiki vs. statyczności, niejawności vs. jawności. itp.

C jest najsłynniejszym słabo wpisanym językiem i nie wykonuje żadnego sprawdzania czasu wykonywania ani sprawdzania czasu kompilacji typu zmiennych. W gruncie rzeczy możesz rzucić char *na a, int *a języka nie obchodzi. Dlaczego miałbyś to zrobić?

Programowanie w C jest bardzo zbliżone do sposobu, w jaki robisz to przy montażu, więc są chwile, w których zależy ci tylko na adresie. Z tego powodu nierzadko rzuca się lub przekazuje void *referencje. Jeśli wiesz, jak zorganizowana jest pamięć (ponownie sprawa C i montażu), możesz wykonać całkiem fajne obliczenia na podstawie adresu w, void *aby uzyskać potrzebne informacje. Może to pozwolić na zerwanie procesu, na przykład w Javie.

Podczas gdy sprawdzanie typu w czasie wykonywania nie ma nadzwyczajnego narzutu, zdarzają się sytuacje, w których wystarczy, aby krytyczna sekcja była zbyt wolna. W tym przypadku myślę głównie o programowaniu wbudowanym i systemach czasu rzeczywistego.

To powiedziawszy, w większości przypadków posiadanie silnego systemu typów, który jest sprawdzany podczas kompilacji lub sprawdzany w czasie wykonywania, pomaga częściej niż boli.

Słabe pisanie jest zazwyczaj łatwiejsze do zrozumienia dla początkujących, na przykład w takich programach, jak Excel, javascript i vbscript. Wymieniasz także pewną prędkość programowania na potencjalne błędy.

Dobry artykuł na ten temat: Mocne pisanie vs Mocne testowanie