5 ms·

I wish he would have used C for everything. You need to buyin into Java's whole OOP thing, which I am not a fan of.

by smnplk 1y ago

nine_k 1y ago
Wren, the topic of the post, is positioned as a descendant of Smalltalk, the most OOP language of them all. The author clearly finds the OOP paradigm important.
thw_9a83c 1y ago
I understand. I wasn't a Java person when I read that book, yet I still prefer Java over more esoteric options. If Golang is easier for you to understand (no OOP), then I can recommend this one: https://interpreterbook.com/ https://interpreterbook.com/ BTW, I'm not the author of either of those books, but I have read both of them.
SatvikBeri 1y ago
It's not too hard to adapt the first half of the book into whatever language you want. People have posted versions in dozens of languages: https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations https://github.com/munificent/craftinginterpreters/wiki/Lox-... (There are fewer options for the second half, since you need more control over memory management.)
- Conscat 1y ago
  It's hard to say what "that hard" should be considered, but the book's first half involves Java reflection, which isn't obvious code to port to different languages in my opinion.
  - pansa2 1y ago
    > the book's first half involves Java reflection Does it? I know it uses metaprogramming (a Java program that outputs another Java program), but that’s probably easier in other languages than in Java. In my Python implementation I was able to significantly simplify that part of the code by using `eval`.
    - scuff3d 1y ago
      Yeah I don't recall reflection either. I do remember him using the visitor pattern to implement part of the parser I think. I thought that was kind of an odd choice, especially since it seemed like he was really just trying to avoid Java boilerplate. Regardless, the book is incredible, and the choice of Java to start with makes sense. Its probably going to be the most universally approachable for everyone, even if they aren't super familiar. C can be pretty overwhelming if you aren't familiar it.
      - pansa2 1y ago
        > I do remember him using the visitor pattern to implement part of the parser I think. I thought that was kind of an odd choice, especially since it seemed like he was really just trying to avoid Java boilerplate. It's used to allow writing a "resolver" and an "interpreter" that both know how to handle every type of node in the AST. It's almost a functional approach, and I actually think it might increase boilerplate because Java is more designed around the object-oriented approach of adding `resolve` and `interpret` methods directly to each node type. The two approaches result in very different code organisation, though - maybe the visitor approach was easier to explain in prose.
        scuff3d 1y ago
        It's been a while since I read it, but I remember him saying something about the more natural (my word not his) approach being a single data structure that you would pass through both components, but he didn't want to do that because Java doesnt really encourage that kind of design, and you have a bunch of boilerplate for each class. It just struck me as an odd choice since the book was more about compiler/interpreter fundamentals, and I feel like the visitor pattern is a bit in the weeds in terms of OOP design. I wonder if he wrote today if he would have used a Record and done the more straightforward implementation.
        nogridbag 1y ago
        I went through the Crafting Interpreters book with modern Java. I posted this on reddit, but I basically used records and sealed interfaces. With modern Java there's no need for visitor pattern. private void execute(Stmt statement) { switch (statement) { case Stmt.Expression expression -> evaluate(expression.expr()); case Stmt.Block block -> executeBlock(block.statements(), new Environment(environment)); ... public sealed interface Expr permits Expr.Assign, Expr.Binary, Expr.Call, Expr.Function, .... more exprs here
  - SatvikBeri 1y ago
    It's been a few years now, but there's no real reason to port the Java code directly – you can just read what it's trying to do, and implement that using your language's idioms. I don't remember anything as complex as trying to port reflection.
codr7 1y ago
I recently did a dual implementation of a simple language in Java/C for educational purposes: https://github.com/codr7/shi https://github.com/codr7/shi

I wish he would have used C for everything. You need to buyin into Java's whole OOP thing, which I am not a fan of.

by smnplk 1y ago

I wish he would have used C for everything. You need to buyin into Java's whole OOP thing, which I am not a fan of.

Wren, the topic of the post, is positioned as a descendant of Smalltalk, the most OOP language of them all. The author clearly finds the OOP paradigm important.

thw_9a83c 1y ago

I understand. I wasn't a Java person when I read that book, yet I still prefer Java over more esoteric options. If Golang is easier for you to understand (no OOP), then I can recommend this one: https://interpreterbook.com/ https://interpreterbook.com/ BTW, I'm not the author of either of those books, but I have read both of them.

SatvikBeri 1y ago

It's not too hard to adapt the first half of the book into whatever language you want. People have posted versions in dozens of languages: https://github.com/munificent/craftinginterpreters/wiki/Lox-implementations https://github.com/munificent/craftinginterpreters/wiki/Lox-... (There are fewer options for the second half, since you need more control over memory management.)

Conscat 1y ago
It's hard to say what "that hard" should be considered, but the book's first half involves Java reflection, which isn't obvious code to port to different languages in my opinion.
- pansa2 1y ago
  > the book's first half involves Java reflection Does it? I know it uses metaprogramming (a Java program that outputs another Java program), but that’s probably easier in other languages than in Java. In my Python implementation I was able to significantly simplify that part of the code by using `eval`.
  - scuff3d 1y ago
    Yeah I don't recall reflection either. I do remember him using the visitor pattern to implement part of the parser I think. I thought that was kind of an odd choice, especially since it seemed like he was really just trying to avoid Java boilerplate. Regardless, the book is incredible, and the choice of Java to start with makes sense. Its probably going to be the most universally approachable for everyone, even if they aren't super familiar. C can be pretty overwhelming if you aren't familiar it.
    - pansa2 1y ago
      > I do remember him using the visitor pattern to implement part of the parser I think. I thought that was kind of an odd choice, especially since it seemed like he was really just trying to avoid Java boilerplate. It's used to allow writing a "resolver" and an "interpreter" that both know how to handle every type of node in the AST. It's almost a functional approach, and I actually think it might increase boilerplate because Java is more designed around the object-oriented approach of adding `resolve` and `interpret` methods directly to each node type. The two approaches result in very different code organisation, though - maybe the visitor approach was easier to explain in prose.
      - scuff3d 1y ago
        It's been a while since I read it, but I remember him saying something about the more natural (my word not his) approach being a single data structure that you would pass through both components, but he didn't want to do that because Java doesnt really encourage that kind of design, and you have a bunch of boilerplate for each class. It just struck me as an odd choice since the book was more about compiler/interpreter fundamentals, and I feel like the visitor pattern is a bit in the weeds in terms of OOP design. I wonder if he wrote today if he would have used a Record and done the more straightforward implementation.
        nogridbag 1y ago
        I went through the Crafting Interpreters book with modern Java. I posted this on reddit, but I basically used records and sealed interfaces. With modern Java there's no need for visitor pattern. private void execute(Stmt statement) { switch (statement) { case Stmt.Expression expression -> evaluate(expression.expr()); case Stmt.Block block -> executeBlock(block.statements(), new Environment(environment)); ... public sealed interface Expr permits Expr.Assign, Expr.Binary, Expr.Call, Expr.Function, .... more exprs here
- SatvikBeri 1y ago
  It's been a few years now, but there's no real reason to port the Java code directly – you can just read what it's trying to do, and implement that using your language's idioms. I don't remember anything as complex as trying to port reflection.

codr7 1y ago

I recently did a dual implementation of a simple language in Java/C for educational purposes: https://github.com/codr7/shi https://github.com/codr7/shi