News for hackers. Stuff that matters.
Re:Crystal 1.0 – What to expect by Doctor_Fegg on Monday March 22, 2021 @03:49PM (#26545864)
Crystal's appeal, for me at least, is the productivity of Ruby with the memory efficiency and execution speed of C++. Static typing is just a way of achieving that, it's not something I'm seeking per se.
Re:Crystal 1.0 – What to expect by socialdemocrat on Monday March 22, 2021 @10:26PM (#26550296)
As an old Ruby fan, you should seriously check out Julia. It had a lot of the same meta programming goodies as Ruby but with performance that often rivals C/C++. Actually I think Julia will frequently pull off being faster. It is crazy how good JIT compilation works today with a language specifically designed designed for it.
Re:Crystal 1.0 – What to expect by straight-shoota on Monday March 22, 2021 @03:58PM (#26545998)
Remember static typing is also really useful for code quality and avoiding hidden bugs. Some code in Ruby requires a ton of specs to discover bugs caused by type issues, while the Crystal compiler tells you immediately that something doesn't work out. I love Crystal's type system really for productivity reasons.
Re:Crystal 1.0 – What to expect by sjwright on Monday March 22, 2021 @05:50PM (#26547725)
I haven’t ever understood the argument against static typing. I’ve never declared a variable and not simultaneously thought “this is going to be a float, always a float, never not a float.”

The only exception to this is untrusted input, but for that an string is usually always fine.

Re:Crystal 1.0 – What to expect by pansa2 on Monday March 22, 2021 @06:51PM (#26548482)
> I’ve never declared a variable and not simultaneously thought “this is going to be a float, always a float, never not a float.”

Never written generic/template code? Making that much easier is one of the main benefits of dynamic typing.

Re:Crystal 1.0 – What to expect by viraptor on Monday March 22, 2021 @07:56PM (#26549149)
Change it to "this variable is always going to be a T, never not a T" and it still stands.
Re:Crystal 1.0 – What to expect by sjwright on Monday March 22, 2021 @11:33PM (#26550773)
It's possible—nay likely—that I don't understand the true value of generics. It's something that I've looked into on occasion and it never seemed all that useful to me. Most examples I've come across in the past were C++ and seemed like formalised workarounds for deficiencies in the C++ type system rather than being actually useful. I'm sure I've failed to grok them—or based on the code I write I'm not the target audience for them.

I have no problem when a language allows the programmer to explicitly opt for a variable to be an undefined/dynamic type, whether as part of generics or as part of a defensive ingest of untrusted data. I admit this is previously unspecified nuance but in my mind this doesn't break my rule: "this variable is always going to be a dynamic type, never not a dynamic type." This means you know when to interact with it defensively.

The thing I'd like in a hybrid static-dynamic language is type assertion blocks which restore some benefits of static typing while dealing with dynamic typed variables. E.g.:

  declare x as dynamic;
  x = untrusted_source();
  if (x IS_A string) {
    // Inside here, x behaves as a statically typed string.
    // The compiler knows it and checks types appropriately.
    // Passing x elsewhere will send a static typed string.
    function_that_demands_a_string(x);
  }
  else if (x CAN_SAFELY_BECOME_A uint) {
    // True for any non-negative integer regardless of data type.
    // Inside here, x is always a statically typed uint.
    // If it was some other type, it was converted for me.
  }
(This probably already exists in some language somewhere but my familiarity with languages is narrow.)
Re:Crystal 1.0 – What to expect by ezrast on Tuesday March 23, 2021 @01:10AM (#26551349)
Crystal does some of what you want:

https://tio.run/##ZVDBbsIwDL33KywmrRcaUXbbhHbeaYdpJ4RQaA1kCk...

Note how the language is pretty smart about flow-typing variables as you narrow down their types. `x` here is typed as a tagged union (String | Int32 | Array(Char) | Float64 | UInt32), but by the time the program gets to the final `else` the compiler has figured out that the String and Array cases have already been dealt with (even though we never mentioned Array by name, just asked if the object implements a method that only Array implements), so it lets us call `x.abs`, which only works for numeric types. Of course, `abs` has different implementations for Int32 and Float64, but the signatures are compatible so the compiler lets it fly, resorting to dynamic dispatch at runtime.

The missing part is that there's nothing like a CAN_SAFELY_BECOME_A operator so I had to implement that test myself (as `try_to_u32`) and call it early to get the flow typing to work.

The Wikipedia article for the concept is https://en.wikipedia.org/wiki/Flow-sensitive_typing

Re:Crystal 1.0 – What to expect by sjwright on Tuesday March 23, 2021 @03:46AM (#26552178)
That's very cool. And especially thanks for surfacing the Wikipedia article.
Re:Crystal 1.0 – What to expect by mekkkkkk on Tuesday March 23, 2021 @07:25AM (#26553718)
The main benefit of generics is to easily maintain strong type information for implementers.

With a

  <T>createMapWithStringKey(T arg) -> Map<string, T>
You can keep strong type info with

  AType a
  var b = createMapWithStringKey<AType>(a)
  // b is for certain a Map<string, AType>
Re:Crystal 1.0 – What to expect by dragonwriter on Tuesday March 23, 2021 @06:46AM (#26553399)
Python typecheckers (both pyright and mypy, I believe) do this (isinstance checks and some other checks in conditionals narrow the type on the defended path.)
Re:Crystal 1.0 – What to expect by aryehof on Wednesday March 24, 2021 @06:09AM (#26565346)
The classic use case for generics is when creating Abstract Data Types. Implementing stacks, queues, dynamic arrays etc of differing Types is made relatively simple using generics.
Re:Crystal 1.0 – What to expect by ncmncm on Monday March 22, 2021 @07:28PM (#26548896)
If all you get from static typing is runtime performance and correctness, your type system is not pulling its weight.

In any serious statically-typed language, the type system does real heavy lifting. In practice that means that libraries execute code at compile time that, in effect, generate the code you would otherwise need to write (again) yourself.

C, Pascal, and Go are examples of statically typed languages whose type system does only trivial work.

Re:Crystal 1.0 – What to expect by onlyrealcuzzo on Monday March 22, 2021 @06:05PM (#26547925)
Is static typing really necessary for speed?

The fastest JavaScript engines and LuaJIT are closer in speed to Crystal than Crystal is to C.

Granted - all these languages are really fast - and unless you're doing something INSANELY performance dependent and you REALLY know what you're doing - I think familiarity trumps all. You're almost certainly going to write faster Crystal code if you're a Crystal expert than you would write C, C++, or Rust.

Re:Crystal 1.0 – What to expect by viraptor on Monday March 22, 2021 @07:51PM (#26549109)
It's not necessary strictly speaking, but it make things MUCH easier. JS in v8 has 3 (4?) layers of compilers already and each time some type changes at runtime you're taking a hit to go back to the interpreted version while functions jit compile again.

There's a crazy amount of engineering effort that has to counteract a missing "this has one parameter and it's either a string or a float" annotation.

In practice if you don't have a world class well funded team - yes, static typing is necessary for performance.

Re:Crystal 1.0 – What to expect by socialdemocrat on Monday March 22, 2021 @10:31PM (#26550325)
That is because JS was not built for JIT compilation. With a dynamic language like Julia built for JIT compilation from the very start you get both much simpler and cleaner design and higher performance.

It uses a method JIT so it is deterministic and easy to analyze unlike JavaScript.

You can lookup ahead of time how each function will get compiled with given input types.

Re:Crystal 1.0 – What to expect by viraptor on Tuesday March 23, 2021 @05:18AM (#26552749)
I'm not sure what you mean by this. Why do you think Julia was made for JIT from the beginning?

You can't analyse functions like this ahead of time:

   function foo(x)
     x + y
   end
You've got an Any type interacting with an Any global. There's no better answer than you'd get from JS analysis.
Re:Crystal 1.0 – What to expect by eigenspace on Tuesday March 23, 2021 @12:22PM (#26556826)
> Why do you think Julia was made for JIT from the beginning?

It's very explicit in almost anything the language designers wrote from the beginning. Julia has always had it's language semantics designed around a JIT. Keep in mind, julia's JIT is not at all like JS JITs, julia's style is often called 'just ahead of time'.

For the you quote, the only thing causing a problem is the global y. Using global variables is very frowned upon in julia for this reason. However, if you write

    function g(y)
        function f(x)
            x + y
        end
    end
or something, then there is no `Any` involved at runtime. What will happen is that say you call g(1.0)(2), as soon as julia sees this, it will do static type inference on the function bodies, knowing that y :: Float64 and x :: Int, all the code can be inferred and compiled down. Julia specializes on all arguments of functions, whether or not you put a type assertion on them.

If there's a point in the program where type inference fails to produce concrete types, then the compiler just generates code up to that point and then waits until the types are resolved at runtime, and then using the new runtime type information does static analysis going forward from that point until it either encounters another type instability, or the program is finished.

This is why writing code that isn't concretely inferrable can carry a heavy performance penalty in julia, but it's also why inferrable code can be so fast. The trick is just to keep type dynamism away from performance bottlenecks and you'll be fine.

Re:Crystal 1.0 – What to expect by otabdeveloper4 on Tuesday March 23, 2021 @04:41AM (#26552534)
Type inference can only get you so far when the language and runtime allow you to devolve values to an 'Optional[Any]' at literally any given statement.

Sometimes discipline must be enforced on the programmer.

Re:Crystal 1.0 – What to expect by socialdemocrat on Monday March 22, 2021 @10:28PM (#26550308)
No, Julia is not statically typed and will outperform pretty much anything, at least when dealing with numerical code.

Next generation climate models are built with Julia. You would not pick a slow language for such a high performance dependent task.

Re:Crystal 1.0 – What to expect by otabdeveloper4 on Tuesday March 23, 2021 @04:37AM (#26552498)
Julia is statically typed, or at least it is for the inner bottleneck loops. If you want fast numeric code in Julia then you have to have homogeneous arrays. (Besides, I'd be very surprised if Julia doesn't have Fortran libraries driving it under the hood.)

You're confusing dynamic typing and type inference.

Re:Crystal 1.0 – What to expect by eigenspace on Tuesday March 23, 2021 @12:27PM (#26556875)
Julia is not statically typed semantically. It has the semantics of a dynamic language.

As an implementation detail, it has a statically typed intermediate representation that's used for very aggressive and impressive optimization.

But that's an implementation detail, and is not what most people mean when they talk about a language being dynamically or statically typed.

Re:Crystal 1.0 – What to expect by junippor on Tuesday March 23, 2021 @10:24AM (#26555383)
https://julialang.org/

> Julia is dynamically typed, feels like a scripting language, and has good support for interactive use.

Literally on the front page.

Re:Crystal 1.0 – What to expect by dklend122 on Tuesday March 23, 2021 @11:01AM (#26555838)
Julia can also generate fast code for arrays of small unions
Re:Crystal 1.0 – What to expect by otabdeveloper4 on Tuesday March 23, 2021 @04:38AM (#26552505)
> Is static typing really necessary for speed?

Absolutely yes. If you don't know the shape of your data at compile time then you're going to destroy your performance discovering and validating it at runtime.