tev VS the-ray-tracer-challenge-fsharp

Hi. I'm a C++ newbie and want to use a simple, modern library to send over a network - specifically to use the tev image viewer's IPC protocol. I don't need anything fancy, just synchronous that I can feed arrays of bytes to. I looked briefly into asio but that seems too complicated for my needs.

In the decade I spent working on RenderMan at Pixar, I learned just how immensely useful it was to have an image viewer running in a separate process talking to the renderer over a socket or pipe. (The Image Tool, or "It" is RenderMan's viewer.) Having it stay up even if you kill the render or it crashes for some reason and being able to flip back and forth to easily compare test renders across recompiles is game changing.

If I were to start writing a new renderer, the first thing I'd do is to hook it up to an external image viewer over some protocol. These days, I find myself liking TEV (https://github.com/Tom94/tev) a lot as a simple open-source image viewer that supports this. See the links in the README for Python and Rust implementations of its protocol.

Take a book that is project-based, such as The Ray Tracer Challenge, no matter what language it uses in the book, and start going through the book in F#. I have done so, for example, here is my in-work F# implementation for the ray tracer book.

Yes, please do! Warning: F# will ruin other languages for you. I find it rather painful to work in basically anything else after using F#, with gradients of pain for different languages. Haha.

And that's a good question. I have basically every book written on F#, but I can't say I have ever used them for anything more than reference.

The official docs/guide/reference are actually really good, and I refer to them a lot when using some feature I'm not familiar with: https://docs.microsoft.com/en-us/dotnet/fsharp/what-is-fshar...

F# For Fun and Profit is well-known, but I can't say I use it a lot: https://fsharpforfunandprofit.com/

The same author's (Scott Wlaschin) book is very good: https://pragprog.com/titles/swdddf/domain-modeling-made-func...

As for books, I have always liked:

* Functional Programming Using F# by Hansen and Rischel (might be too simple if you are already comfortable with functional programming and is out of date every now and then with changes to F# that's happened)

* Expert F# 4.0 by Don Syme and others (contains a lot of nice things by the designer of F#

One of the latest books is Stylish F# 6: Crafting Elegant Functional Code for .NET 6 by Kit Eason. I have the first edition but haven't read it.

My personal recommendation is to take the approach of type/domain driven design. That is, I start off every F# module the same:

1. Define my types with discriminated unions, records, type aliases (such as for tuples) or single case discriminated unions. Use classes when necessary but try to prefer the more functional types.

2. Start writing functions against these.

And that's basically it. One thing to recognize with F# is that it mixes OOP rather nicely. Even discriminated unions and records, which are immutable, can have members defined on them, including operator overloading (something F# is pretty good about). They can even implement interfaces and be defined with generic types, which is also nice and powerful.

I have some projects that might of interest, since they're simple enough and illustrate the above process.

https://github.com/bmitc/the-ray-tracer-challenge-fsharp

https://github.com/bmitc/nand2tetris

Lastly, I'd suggest just starting up some projects. You could also take the Programming Languages course on Coursera by Dan Grossman. Part A uses SML, and you could port the examples and homework solutions to F# (I did so when I took the course). I also take books written for other languages and port the code to F#, usually taking a more idiomatic functional style. .NET Interactive notebooks (https://github.com/dotnet/interactive) are a great way to get started. You just need to install the .NET 6 SDK (which gets you F#) and then install the .NET Interactive Notebook extension in VS Code. That's it. There is also the book The Little MLer which gets people comfortable with discriminated unions (sum types), and I used the book and ported the examples to F#. I need to go back and finish that annotation project (https://github.com/bmitc/the-little-fsharper). I'll probably convert the script files to .NET Interactive notebooks if I do.

Here's mine, which is only about halfway through: https://github.com/bmitc/the-ray-tracer-challenge-fsharp

I used FsUnit here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/tree/main/RayTracerChallenge/XUnitTests

Yes, the book has both implementations of the required functions (for all the complicated ones you need) and tests all written in pseudocode.

The book is really good. I have a half-finished implementation in F#, and what I find striking is just how close the F# code is to the pseudocode. I have also started an idiomatic port to Racket but have only done the tuples, vector, and point implementations so far. I need to pick these up again.

https://github.com/bmitc/the-ray-tracer-challenge-fsharp

https://github.com/bmitc/the-ray-tracer-challenge-racket

I mean, check this out: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/blo...

I have also worked through pieces of Ray Tracing in One Weekend (what was referenced in this post). They get you going much faster, but the code is written in C++. I found the translation to a functional style was harder (was just using Racket and F#'s mutability features), whereas the way The Ray Tracer Challenge is laid out and specified, I found it much easier to translate to an idiomatic functional style.

Another project of mine is going through the book The Ray Tracer Challenge with F#. The book is language agnostic and represents the code with pseudocode and presents a test driven approach. My repository is here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp

I highly recommend the two books:

Ray Tracing in One Weekend: https://www.amazon.com/dp/B01B5AODD8/

The Ray Tracer Challenge: https://www.amazon.com/dp/1680502719/

For the latter, I have made it a pretty good way through the book, implementing a functional (in the programming paradigm sense) version of the ray tracer in F#. It’s actually rather mind boggling how close the F# code and tests are to the psuedocode found in the book.

https://github.com/bmitc/the-ray-tracer-challenge-fsharp