the-ray-tracer-challenge-fsharp
mal
Our great sponsors
the-ray-tracer-challenge-fsharp | mal | |
---|---|---|
10 | 94 | |
19 | 9,792 | |
- | - | |
4.0 | 0.0 | |
7 months ago | 30 days ago | |
F# | Assembly | |
MIT License | GNU General Public License v3.0 or later |
Stars - the number of stars that a project has on GitHub. Growth - month over month growth in stars.
Activity is a relative number indicating how actively a project is being developed. Recent commits have higher weight than older ones.
For example, an activity of 9.0 indicates that a project is amongst the top 10% of the most actively developed projects that we are tracking.
the-ray-tracer-challenge-fsharp
-
Good book to learn F#?
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.
-
OCaml at First Glance
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.
-
What are you working on? (2022-07)
Here's mine, which is only about halfway through: https://github.com/bmitc/the-ray-tracer-challenge-fsharp
-
Das.Test - an opinionated unit testing library written in F# for F#
I used FsUnit here: https://github.com/bmitc/the-ray-tracer-challenge-fsharp/tree/main/RayTracerChallenge/XUnitTests
-
The joy of building a ray tracer, for fun, in Rust
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.
- Really great example projects?
- Is F# Tough to Learn?
- What are F#'s advantages?
-
Can anyone suggest any interesting F# projects?
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
-
Super simple ray tracer guide after first math semester
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.
mal
-
Ask HN: Is Lisp Simple?
>Would be interesting to see how the interpreter works actually...
It's quite easy to see, there are interpeters for Lisp in like 20 lines or so.
Here's a good one:
(It has the full code in a link towards the bottom)
There's also this:
- GitHub - kanaka/mal: mal - Make a Lisp
-
Build Your Own Lisp
Here is one implementation of a lisp (mal specifically) in matlab: https://github.com/kanaka/mal/blob/dcf8f4d7b9cf7b858850a04a0...
Only 260 lines of code, pretty concise :)
-
Found inside my compiler I've been writing for about 2 years
have a look at the crafting interpreters book, plus make a lisp (lisp is a great first language to make a compiler/interpreter for, just google "lisp compiler/interpreter" and you'll find lots of resources)
- Ce proiecte for-fun ati facut in timpul facultatii ca sa invatati ceva nou si practic singuri?
-
Crafting Interpreters or Writing an Interpreter in Go? Given context
If you're really okay with the limitations of a tree-walk interpreter, you might want to check out MAL, which will teach you how to write a tree-walk interpreter for a LISP. The code for MAL has been translated to most popular languages, so you can work through the creation of an interpreter in the language of your choice. JLox would give you a bit more detail and a more complex language, but I'm not convinced that it's all that important.
-
What do I do now?
Write a small programming language (lisp (https://github.com/kanaka/mal) or brainfuck) in C++ to learn the syntax more. This will teach you a lot about programming languages in general.
- Ask HN: What projects did you build to get better as a programmer?
-
Can you beat my dad at Scrabble?
So I started some hobbyist game dev using Unity and realised that the full process of making a game has dependencies on a mass of lower-level skills including lighting virtual environments. As a hobbyist photographer I could see some useful analogies from lighting studios and other scenes
So I pivoted, and eventually made money, not from selling a game, but from developing tutorials about digital lighting. I was also able to contribute to a project at work that was making a product based on commercial games engine, not by actually coding it, but by helping to better estimate the costs of the asset generation required.
Coding Unity object scripts in C# also got me back into programming, and I went on to successfully build a self-hosting lisp interpreter following the Make a Lisp guidelines [0].
[0] https://github.com/kanaka/mal/blob/master/process/guide.md
-
Advice for a first-time designer of my own original programming language? Presently writing the interpreter!
Hijacking the top comment to add https://buildyourownlisp.com and https://github.com/kanaka/mal
What are some alternatives?
nand2tetris - Original course HDL solutions, F# implementations for the software stack, and VHDL implementations for the hardware stack for the nand2tetris course and The Elements of Computing Systems book.
paip-lisp - Lisp code for the textbook "Paradigms of Artificial Intelligence Programming"
Bolero - Bolero brings Blazor to F# developers with an easy to use Model-View-Update architecture, HTML combinators, hot reloaded templates, type-safe endpoints, advanced routing and remoting capabilities, and more.
Lua - Lua is a powerful, efficient, lightweight, embeddable scripting language. It supports procedural programming, object-oriented programming, functional programming, data-driven programming, and data description.
equinox - .NET event sourcing library with CosmosDB, DynamoDB, EventStoreDB, message-db, SqlStreamStore and integration test backends. Focused at stream level; see https://github.com/jet/propulsion for cross-stream projections/subscriptions/reactions
sectorlisp - Bootstrapping LISP in a Boot Sector
the-ray-tracer-challenge-racket - Racket implementations of the ray tracer found in The Ray Tracer Challenge book by Jamis Buck.
project-based-learning - Curated list of project-based tutorials
CardManagement
hy - A dialect of Lisp that's embedded in Python
minifb - MiniFB is a small cross platform library to create a frame buffer that you can draw pixels in
wisp - A little Clojure-like LISP in JavaScript