Dynamic typing

There are plenty of statically typed languages that have metaprogramming just as powerful as Lisp and there are also statically typed Lisp variants.

>statically typed languages that have metaprogramming just as powerful as Lisp and there are also statically typed Lisp variants.

Sources?

While they are unityped, they have runtime checking of values. That's what most people usually mean when they say "dynamic typing" even though this construct is more like contracts of different levels of sophistication than types. (Sometimes it's implemented as just straight-up contracts.)

...

shenlanguage.org/
github.com/carp-lang/carp
But then Lisp programmers tend to disagree what counts as a Lisp. The most extreme say that Scheme isn't a Lisp.

>Carp looks like Jow Forums language
No OOP,No GC, high integration C and lisp

A true lan/g/uage should be lazy.

We love Clojure because it is expressive, modern, and built on the shoulders of giants. We love it because it enables us to create abstractions that we couldn’t otherwise get when constrained to the JVM and JavaScript world.

Carp is a statically typed, compiled Lisp that’s deeply rooted in Clojure. It also takes inspirations from Rust, in that it uses a borrow checker to manage memory. This allows us to create a powerful, pretty Lisp that combines great C interoperability, safe memory semantics, and inferred types to make your life easy and enjoyable. In one sentence: it is to C as Clojure is to Java.

I’d like to give you a glimpse of the language and its semantics and show you how it is similar and different from Clojure at the same time. I’m going to share the philosophy and current state of the language, as well as what’s to come and what’s missing.
youtube.com/watch?v=BQeG6fXMk28&feature=youtu.be

every language has dynamic typing to some extent.
Full static typing is equivalent to formally proven code.

Python has dynamic typing. That's why it's one of the most used languages and will be THE most used language in less than 5 years

Attached: python.jpg (768x768, 33K)

>How
It was a joke you dumb piece of shit

Oopsie poopsie

What is dynamic typing?

Attached: slide_5.jpg (960x720, 88K)

>That's why
Yes and no. Python is popular because it's pretty expressive and easy to use. It is dynamically typed because it was created and became popular at a time when the language landscape was generally seen in terms of expressive, high-level unityped languages like Smalltalk and Lisp vs. less expressive, lower-level typed languages like C++. Maybe a typed Python with powerful type inference wouldn't have succeeded back then because of the fashion of the time, but its ease to use doesn't inherently require unityping.

There is no direct equivalent of Python with types (don't say "Nim"), but Crystal and Ruby show us what could have been. Crystal is a language with an advanced type system where 90% of the lines the programmer writes are the same he would write in Ruby. Ruby fans who switch to Crystal have no trouble adapting to it and find it easy to write. There is one usability problem with Crystal directly caused by how it works and that is the lack of a real REPL.

>Python is popular because it's pretty expressive and easy to use
there is nothing expressive about Python, Python syntax might look like pseudocode at first glance but the language itself is very inconsistent and poorly designed.

>There is no direct equivalent of Python with types (don't say "Nim")
Dart has optional types. And Dart is not just a transpolar language like TypeScript (which also has optional types) but a stand alone interpreter that could be used as a general purpose scripting language.

And to address the first problem, Dart has Java-like syntax, in fact if you know Java, you know most of Dart from the get go. Dart is also very fast, it was made by the same guy who made the V8 Javascript implementation. There is no reason to be using Python anymore.

> the language itself is very inconsistent and poorly designed

This. Python is one of the worst "designed" languages in mainstream use. PHP is the only one that is potentially worse. Outside of implicit conversions, which are easily avoidable, even JavaScript is better in every way.

>Dart has optional types

Google realized that both dynamic and optional typing are retarded and version 2 of Dart and onwards is fully statically typed.

>In terms of type theory
>among mathematicians
>type theorists
spotted the haskelltard

>there is nothing expressive about Python
There is no point to speaking dumb exaggerations. Python was expressive compared to what it competed with, like Java and C++, and less batshit than Perl.

P.S.: There is approximately 0% chance you use Dart if you weren't aware of its static typing.

>>there is nothing expressive about Python
>There is no point to speaking dumb exaggerations. Python was expressive compared to what it competed with, like Java and C++, and less batshit than Perl.
>P.S.: There is approximately 0% chance you use Dart if you weren't aware of its static typing.
There is NOTHING "expressive" about Python, its a cute language for simple scripts that attracts beginners, its not a language capable of handling thousands of lines of code in any coherent kind of way, Dart is. "Expressive" is a just a fluff word that doesn't mean anything that people throw about to hype dying languages.

Sure thing Python sucks. Doesn't mean you should shill Dart when you don't even use it.

I use it for Flutter

How did you not know about Dart 2.0's static typing?

>among type theorists untyped languages are widely considered dogshit.

ya dont say?

Attached: orang.jpg (800x452, 67K)

>So the problem is—I’ve said this about both Smalltalk and Lisp—they tend to eat their young. What I mean is that both Lisp and Smalltalk are really fabulous vehicles, because they have a meta-system. They have so many ways of dealing with problems that the early-binding languages don’t have, that it’s very, very difficult for people who like Lisp or Smalltalk to imagine anything else.
>t. Alan Kay
queue.acm.org/detail.cfm?id=1039523

No opinions on the people, but I think dynamically typed languages are absolute shit.

I feel that the laziness problem (I don't care about the type, I just want to write "var" for everything) can be solved with an automatic type (C++ "auto" and c# "var"), which resolves at compile time so it's still static but you don't have to care.

The problem of adding code later can be solved with a well designed interface. In fact, an interface makes it better.

Shen's macro system isn't statically typed. Also, its type system is implemented in Prolog, so you actually get worse error messages/type hinting with static typing on than off - and it's Turing complete, which is not really desirable for a type checking algorithm

The term your are looking for is 'type inference'.
en.wikipedia.org/wiki/Type_inference

>Shen's macro system isn't statically typed.
I think the point is that the language itself is.

ignorance

ppl who criticize python - most of them are just wannabe programmers on here, repeating some meme. idiots

I haven't used it for 6 months now

Sure, but the user I was replying to was replying to an user saying Lisps need dynamic typing for metaprogramming. Just pointing out Shen is not a counterexample.

It is really a use of dynamic typing for metaprogramming when you transform statically typed code into statically typed code?

What does it even mean?
Is it when you type on your keyboard and OS changes your keyboard layout randomly while you type and then screens at you with large warning window that user now must type in Dvorak layout?

This doesn't make any sense

Attached: 1516581790059.png (741x568, 29K)

He's talking about programming language type systems.

>muh expressiveness
Meanwhile I needed to restart my python server on my raspberry 2 times, since I created some variables out of thin air, because I made some typos.

>Simple scripts
>Beginners
>Not capable of handling thousands of lines of code
Then why the fuck does youtube and facebook use it so damn much.
It actually is a serviceable language for server back-ends.

That's wrong, though. And "untyped" really means "unityped" anyway. Terms of the "untyped" lambda calculus actually all have the type D where D = D -> D. This is significant to its semantics. You can't say this about run of the mill dynamically typed languages like Python or Lisp.

Sure you can. Why aren't the expressions of a Lisp program inhabitants of a unitype if you can pass them anywhere and bind them to any symbol?

About the same as I feel about retards using grave accents as quotation marks.

Because the runtime will complain if you try to use a number as a cons cell. You're probably confused since it's possible to model dynamic typing in static typing with a single type with variants for every dynamic type but that doesn't mean that dynamic typing doesn't exist.

Also I think it's a huge leap to say type theorists hate "untyped" languages when type theory depends on term assignment born from lambda calculus to be useful. There may not be a logical equivalent to the "untyped" lambda calculus but it is sure as hell useful for semantics.

>muh type theory job
I wonder if they could be biased.

>You're probably confused since it's possible to model dynamic typing in static typing with a single type with variants for every dynamic type
What happens if a type assertion fails in this model?
Then try to explain how that's different to """dynamic""" typing.

The model behaves the same way as the real thing, is that so surprising?

>How do you feel about dynamic ``typing'' zealots?
dynamic typing at runtime is cancer.
The performance hit is too big.
Also it's so harder to read that brainlets needed to build tools to fake types
github.com/facebook/flow

>too big
depends on use case

Then the model is perfect and it's an isomorphism.
If you were to remove everything from the static language except the unitype, then you would have a dynamic language.

I'm not sure where you are getting the idea that you can only check types statically and that if it's done dynamically it must be something other than types.

>type theorists
>people actually study programming language datatypes

The absolute state of academia.

Attached: 0afb38ca18805159b668c4e0fddfb0965c752e6a585ec320c417da23b9a835fc.jpg (409x535, 44K)

>t. brainlet

In the context of program typing, sure. If a type is a dynamic assertion then there's no point using the term because it doesn't actually distinguish it from any other kind of predicate checking. In other words it's useless distinguishing types from assertions we can make up new types for literally any assertable value category.

>The absolute state of academia.
You should go to Jow Forumsscience if you want to laugh at scientists
for example :
reddit.com/r/science/comments/9qymux/taller_people_have_a_greater_risk_of_cancer/
There are people on this planet paid to discover shit like this.
>more cells in body == more chance of cancer
no shit

You do realize that type theory is all about identifying types with logical propositions and predicates, right? Jesus your argument is a trainwreck.

Type theory predates data types by half a century or so.