Perl 6 – Getting beyond static vs. dynamic [pdf]

https://fosdem.org/2015/schedule/event/perl6_beyond_dynamic_vs_static/attachments/slides/724/export/events/attachments/perl6_beyond_dynamic_vs_static/slides/724/2015_fosdem_static_dynamic.pdf

by lelf • 11 years ago

91 45 11 years ago

fosdem.org

buster• 11 years ago

I can see how he can be amazed by simple stuff, like typos etc. The moroning example would be catched by python tools like pyflake, or compilers in case of C or rust or whatever... Still he reserves several slides for something i consider most basic, even in other dynamic languages through tooling (truth be told it wouldn't be caught by the interpreter at "compile time"). It's likely such a surprise for him because perl5 was pretty much not even parseable to tell such things..

giancarlostoro2• 11 years ago

A number of IDE's these days have spell checkers (JetBrains comes to mind).

espadrine• 11 years ago

Those spell checkers are easier to make if the language already includes tooling to support that functionality.

kbenson5• 11 years ago

I humbly suggest that you may have missed the point. That was simply an example to illustrate the point, which is on slides 20-22. The rest of the talk expounds on this.

draegtun• 11 years ago

The moroning example gets caught at compile time in perl6 and also in perl5...

  $ perl -Mstrict -M"feature 'say'" -c morning.pl 
  Global symbol "$moroning" requires explicit package name at morning.pl line 7.
  morning.pl had compilation errors.

raiph6• 11 years ago

It's likely such a surprise for him because perl5 was pretty much not even parseable to tell such things.

Jonathan got an honors degree from Cambridge University in CS specializing in compilers etc. If you pay attention to his slides you'll see he's paid to train others to use a variety of languages (all kinda boring ones, except P6 imo, but still). Imo you are underestimating his expertise and the import of what he's saying in his presentation.

The bit that I'm still confused about is how the interleaving of run-time inside compile-time inside run-time inside compile-time etc. contributes to the imposition of compile-time type checking via run-time code and how far that paradigm can go. I'd appreciate you (or anyone else) carefully explaining that bit to me. :)

xiaq• 11 years ago

This is the best part of Perl 6. I am not familiar with the terminology, but it seems "not just" gradual typing to me.

I always it puzzling that to avoid the tedious parts of static type systems, people throw away static checking entirely. As demonstrated by Perl 6 and other gradual typing systems, the whole dualism is imaginary.

I wish that the "runtime dynamicity with as much compile-time staticity as possible" idea will be the norm in the dynamic language community. I wish that someday when we talk about the days of 100% dynamicity with no static checking, we can remark that we have luckily passed that dark age.

pekk• 11 years ago

I always find it puzzling that people throw away dynamic typing entirely. You can't make decisions about what's best for me based on rules of thumb like "as much static typing as possible," your use cases probably don't match mine if you don't understand why anyone would want dynamic typing.

mmphosis• 11 years ago

Time, random, user input, self-modifying self-compiling code, undetermined function results, ...

I agree that there are no absolute rules. A fixed system is boring, and often very inefficient depending how you look at it. Sure my system is static, but inside the black box there is a lot of "dynamism" that I can't change without a recompile. The development environment is dynamic. Writing code, creating the rules, and creating the locked down static types are all dynamic actions. There is no need for a separation between developer/user. User can set the rules, create the workflow, compile the code on the fly. There is no need for a separation between compile and run time.

GHC is itself written in Haskell (utilizing a technique known as bootstrapping), but the runtime system for Haskell, essential to run programs, is written in C and C−−.

I don't know much about C--, but C, what Haskell's runtime is written in, is fairly dynamic.

sparkie• 11 years ago

The reason is simple: Using a statically typed language (particularly one with reflection capabilities), it's trivial to do pretty much anything a dynamic language is capable of doing without extra tooling, perhaps with just a bit more verbosity in code. On the other hand, attempting to simulate static typing with an entirely dynamic language doesn't happen without extra tooling around the compiler.

Even languages with strict type systems like Haskell don't entirely throw away dynamic typing. It has `unsafeCoerce` which can attempt to cast a value at runtime, and fail if it's not the right type like any dynamic language would. However, when combined with Data.Typeable, storing type information in addition to the values you're interested in allows you to turn `unsafeCoerce` into something much safer: `fromDynamic`, which doesn't cause the runtime to fail, but instead returns a Maybe type - one that either contains a successfully coerced value or Nothing - and the language forces you to check this before you can use the value. You have the best of both worlds now - the ability to write whatever dynamic typed code you want, but with the ability to fall back to a strict type system to keep things in check.

tome• 11 years ago

Care to say a bit about your use cases that you consider inappropriate for static typing?

tel6• 11 years ago

From the static typing POV, the dualism is imaginary because gradual types are a perfectly acceptable and long known static type system. This is the real point of the "unityped" argument.

raiph6• 11 years ago

Right. I think it's reasonable to say that all P6 code is statically typed, using nominal typing.[1]

I've not actually checked the following code yet. I just wanted to post it now and will return to update after I've tested this stuff tonight, but here's what I'm currently thinking:

* The Any type is the default value type.

* Built-in literals are automatically converted in to more specific value types at the time they are encountered by the compiler:

  my $a;   # $a contains an `(Any)` aka an undefined Any
  $a = 42; # puts an Int value into $a

* User defined literals and run-time string input are also supposed to be optionally automatically converted from an Any into a more specific type on assignment, but that's not yet implemented in the Rakudo P6 compiler.

* Optional explicit types improve type-checking on assignment:

  my Int      $d = 22/7; # compile-time error

* Not yet implemented but due to land soon:

  my Int(Any) $e = 22/7; # coerces 22/7 (a Rat, thus an Any)
                         # to 3 (an Int) at compile-time

* And for calls:

  sub add (Int $x, Int $y) { $x + $y }

  my     $a = 42;
  my     $b = '42';
  my Str $c = '42';

  add($a, $a); # OK
  add($a, $b); # run-time error?
  add($a, $c); # compile-time error

* Optional explicit types enable multisub dispatch:

  sub add (Int $x, Str $y) { say "oops!" }

  add($a, $c); # resolves to above sub at compile-time
               # says "oops!" at run-time

* P6 allows users to introduce "subsets". Subsets combine a base type (always static/compile-time) with additional constraint logic. The additional constraint may force the subset to become partially dynamic rather than solely static.

* Subsets can be applied in an assignment or signature:

  my enum Day ['Sun','Mon','Tue','Wed','Thu','Fri','Sat'];
  subset Weekday of Day where 'Mon' .. 'Fri';

  my Weekday $wd = Sat; # compile-time error

  sub foo (Weekday $wd) { ... }

* The additional constraint logic of a subset is a P6 "smart match" -- arbitrary code that accepts or rejects a specific value of the base type. In the Weekday subset above the constraint logic is `'Mon' .. 'Fri';`.

* If code analysis can deduce a finite set from the combination of base type and the additional constraint logic, then a compiler may choose to make the whole subset static and check and resolve calls and constrained assignments at compile-time. Otherwise the static part of a subset is checked at compile-time, which may lead to a particular call being among the candidates for a final dispatch, and then there may be a final round of call resolution and checking at run-time.

* Assignments and function calls that don't involve dynamic subsets, or where the compiler can eliminate them from consideration at compile-time, are type checked and dispatch resolved at compile-time.

* Methods are always dispatch resolved at run-time.

[1] http://en.wikipedia.org/wiki/Nominal_type_system

cbd19844• 11 years ago

the "unityped" argument.

Which is a gross, deliberate misunderstanding of how dynamic typing works.

_pmf_• 11 years ago

Every time I read something like this about Perl, I'm amazed at how much it got right.

agumonkey5• 11 years ago

Questions ? Projects[1] stepping onto Meta-Objects territory, why not using Common Lisp ?

[1] There were a few talks on youtube about "advanced python programming" who were about similar ideas.

kbenson5• 11 years ago

How about why use Common Lisp? Lay out some reasons and convince us. That sounds like an interesting discussion.

agumonkey5• 11 years ago

Because they've been investigating MetaObjects (and MetaObject Protocols) since the 80s. Sorry for the smugness, my argument boils down to "Don't reinvent the wheel too much".

estava• 11 years ago

Seems kind of sweet. Except for the prefixing symbols.

rurban3• 11 years ago

It might be worth mentioning that I'm working on a similar type system for perl5 for quite some time, which is efficient like perl6. In contrast to Moose, which is inefficient and more about the MOP. Types there are only used to slow things down, not to speed it up. All these things were developed around 2002, just forgotten and then partially destroyed with 5.10 and ongoing.

Perl5 hates it, but they haven't seen it and they have generally no idea. It is entirely doable in perl5 only. I got 2-6x speedups in prototypes. But then, perl6 has so much more features worth switching over.

esaym• 11 years ago

This looks awesome!

Perl 6 – Getting beyond static vs. dynamic [pdf]

Related Stories