I find it very handy that the intermediate Erlang (or JS) files are available in the build directory. It lets you easily see what form your code will take when compiled.
It seems that Gleam is really useful for those who are already in either the Erlang/Javascript ecosystem.
For me personally, the Javascript target is the least interesting bit - the BEAM/Erlang target is where it's at for backend work. The BEAM is fascinating and full of ideas that were once ahead-of-their-time but now are really coming into their own with compute performance having caught up.
Gleam is a strongly typed language, and is unapologetically very functional. Error handling in general is quite different than it would be on a normal stack-based language/vm. In my experience, the Erlang target doesn't make debugging any harder or more difficult than you would expect for an exception-less language.
I've created Vleam[0] to convert an existing vue webapp[1] and so far it's a joy.
[0]: https://github.com/vleam/vleam
[1]: https://blog.nestful.app/p/why-i-rewrote-nestful-in-gleam
Besides, Gleam's original aim was basically "Erlang but static types", so the choice of Erlang as runtime was always there.
https://blog.lambdaclass.com/an-interview-with-the-creator-o...
> The Gleam compiler has had a few full rewrites. The previous version compiled to BEAM bytecode via Core Erlang, which is an intermediate representation with the Erlang compiler, but the current version compiles to regular Erlang source code that has been pretty-printed. This has a few nice advantages such as providing an escape hatch for people who no longer wish to use Gleam, and enabling Erlang/Elixir/etc projects to use libraries written in Gleam without having to install the Gleam compiler.
Pretty good reasoning in my opinion.
It would be great if the BEAM had a source map like system so it can have the same high quality runtime errors and debugger support that JS has, but I think that’s unlikely to ever happen.
A REPL would be nice, but there hasn’t been enough demand to motivate any work so far. Language server features are overwhelming the majority of demand when it comes to tooling.
I wonder if it's supported with Gleam and/or gleam_otp? Don't see it in the docs.
very very good
// Division by zero is not an error
io.debug(3.14 /. 0.0)
It prints 0
Yuck. Division by zero is an unfortunate reality but basically nobody with mathematical background thinks that just defining x/0 = 0 is a good solution.
Often in numerical computing, getting an NaN or Inf is a blessing in that it’s a hint that your algorithm is numerically buggy, in the same way that a crash or a exception would indicate a program bug.
This approach is the numeric equivalent of a program continuing on after an undefined variable, just assuming it’s 0. That was tried by scripting languages in the 90s and these days most folks think it was a bad approach.
> Gleam does not implicitly throw exceptions, so throwing an exception is not an option. The BEAM VM does not have a Infinity value, so that is not an option. Therefore Gleam returns 0 when dividing by zero.
> The standard library provides functions which return a Result type for division by zero which you can use if that is more suitable for your program.
You can also use Guards[2] to prevent handle a divide-by-zero situation before you attempt it.
[1] https://gleam.run/frequently-asked-questions/#why-does-divis...
1.0 /. 5.0e-324
1.0e308 +. 1.0e308
float.divide(1.0, 5.0e-324)
If Gleam wants to be consistent with division, all float operations would have to return a `Result` type (which I assume would have a direct impact in both performance and user convenience). Plus `let assert` provides a hatch for any function to raise too, and that includes matching on unmapped floats:
let assert <<a:float>> = <<0x7FF0000000000000:64>>A problem that Gleam has here is that the Erlang runtime does not have NaN or Inf in its float type (or integer type for that matter). It could be represented with an atom, but that would require an atom and a float having the same type in Gleam, which is not something the type system can do (by design). The operator could, in theory, return a Result(Float, DivisionByZeroError), but that would make using it very inconvenient. Thus zero was chosen, and there is an equivalent function in the stdlib that returns a result instead, if you wish to check for division by zero.
Just fine mathematically, but Hillel does specify that he's not comfortable with the concept from a safety perspective. The whole piece is a defence against a particular type of criticism, but he leaves wide open the question of whether it's a good idea from a PL perspective.
I'm sure it doesn't work for everybody, but I never had a specific need to deal with zero in the division that didn't result with "actually let's count it as 0"
Imagine that you are running some A/B tests and you want to track conversions. If one of the experiments received 10 users and had 5 conversions, you want to show 50%. If it received 10 users and had no conversions, you will show 0%.
However, if it has received 0 users, while you could show zero conversions, the correct answer is to say that you don't know the conversion rate. Because maybe, if you had had 10 users, they could have all converted, and the rate would be 100%. You simply don't know.
Same logic applies over computing ROI, interest, velocity, etc.
In python for instance, the developer needs to be prepared to catch a divide by zero exception.
In gleam, the same consideration is required but the implementation will just differ.
I don't actually see an issue here. It's a potential gotcha, but once you are aware of this feature of the language, it's no different than any other.
> In gleam, the same consideration is required but the implementation will just differ.
These aren't remotely the same. If a developer fails to catch an exception or a NaN then the program either crashes or returns an obviously wrong result. If a developer fails to guard against a zero returned from division then they get a number out that's wrong in subtle ways that may not be obvious until the wrong numbers are already in use somehow.
The question isn't whether you can work around the error, it's how likely you are to notice that you screwed something up before it's too late.
In Python and languages with similar behavior, a division by 0 will immediately crash your program with a pretty stack trace, showing you exactly where the problem is and how the program got there.
In languages where division by 0 produces infinity, NaN, 0 or similar, your calculation just returns a nonsensical result.
Zero is even worse than inf or NaN, as you may not even realize that there was an error in the first place, as the result of your calculation is a number and not a strange-looking value.
Moreover, it’s actually pretty common for proof assistants to adopt the x/0 = 0 convention, as it turns a partial function into a total one! Having something like NaN or Inf is definitely a better solution in practice, but x/0 = 0 does have its merits!
• Elixir allows for more flexibility and faster prototyping. • Elixir's ecosystem is superior and more mature. • Elixir compiles to BEAM bytecode whereas Gleam compiles to Erlang which then compiles to BEAM bytecode. • Elixir supports Lisp-style macros. • Elixir excels at web development, data processing, and distributed systems. • Elixir's OTP implementation is better.
Since Gleam doesn't support macros, my guess is that Gleam isn't going to be able to run Phoenix-like or LiveView-like frameworks, but I haven't really looked at it, so I could be wrong (edited because what I said wasn't clear, and probably still isn't).
I don't mean to knock Gleam, but it feels to me like a project that came about to add static typing to what Elixir already does, and while it has accomplished that, it has failed, so far, to live up to all the other great things Elixir and Erlang do. I know it's still a young language, so maybe someday they'll get there, but they're not there yet. After coding for 33+ years, I just don't find static typing to be all that compelling or important to me, so I would never choose Gleam over Elixir as things currently stand.
Server-side state management offers several advantages over in-browser state management, such as:
• Better security and privacy.
• More reliability and control.
• Better and more predictable performance since it removes the burden from the client device.
• More accurate user metrics.
• Minimizes browser compatibility issues.
• Better scalability when prioritizing user data security.
• Easier debugging.
(Edited to fix bullet formatting.)
Why do language authors insist the majority of programmers want to type this way? Meaningless arrows and redundant colons.
Is it constructive, like it will lead us to think differently? It feels more like a contest in overcomplicating something as innocent as:
int add(int x, int y)
In particular if you removed the types from yours it’d be add(x, y) and the parser wouldn’t be able to distinguish that from a function call. I think that’s why the fn keyword is really useful for the parser.
The arrow is also conventional in ML family languages, which are a venerable branch of programming whose traditions I respect and enjoy. That's not enough reason alone to keep it maybe but it's not nothing either.
The colon thing whatever, I truly just can't bring myself to care about such fine-grained specifics of syntax. It sounds like a rough life honestly.
I'm biased, having been immersed in PL thoery for a while, but I prefer the colon notation. It works better with type inference, for example. Consider declaring a variable in two ways:
var x: int = 3;
// Now add type inference
var x = 3;
int x = 3;
// Now add type inference
var x = 3; // We've just changed the type to a keyword and that's weird.
F : A -> B
F ∈ A -> B
A -> B ϶ F, and
B <- A ϶ F too.That's not to say ORM's don't exist in FP, but they are not nearly as common because their concept doesn't directly translate into what you expect from a functional language.
That is to say this is not a Gleam problem, it is a FP problem, if we can even call it a problem (it's mostly just different).
If what you meant was the first one then, no I'm not expecting anything like that. I honestly like using a language that gets off of the way and let's me focus on what I want to build. I've done very little OOP and I've written a lot of Rust. There are many situations where I feel like r rusts verbosity is limiting my freedom but the grind of unmarshaling hashmaps into structures is way too much for me. Why shouldn't I want to use my languages typing support to help me write more maintainable code?
I can hardly get over how dart sometimes outright refuses to cast Object types to dynamic types without some syntactical voodoo.
You're focused on OO ORMs as the way to simplify working with queries, but FP approaches it slightly differently.
Regarding macros - Gleam has stated they are interested in adding metaprogramming, but it's not a huge priority because of the goals of the language.
Macros, and metaprogramming in general have a tendency to complicate a language, and encourages ad-hoc DSL's. One of Gleam's goals is to be dead simple to pick up, read, and contribute - metaprogramming makes that much harder.
Macros are not necessary, even if their absence is a bit of a shock at first. I used to firmly think they were necessary, but now my mind has changed on this for the most part.
Go also has best-in-class support for code generation. It isn’t as good as the best macro systems, but it works really well in my experience, despite the duct-tape. It also doesn’t obliterate compile times. Check out Ent - it’s a really pleasant “ORM”.
In Rust for example you use a simple declarative approach and it uses the type system to serialize/deserialize properly.
But in Gleam you need to do everything manually. Even with libraries that's a ton of manual work you need to do.
It's the single reason why I shy away from using Gleam actually.
That second part is wrong. Gleam has type inference.
> Gleam is a statically-typed language, meaning if you declare the type of a variable before using it, that will actually do something.
:)