Ferret: a Lisp implementation for real time embedded control systems

by tosh • 8 years ago

135 36 8 years ago

garganzol• 8 years ago

Where is the source code of a compiler? It looks like it's written in Java but there are no source code files in corresponding GitHub repo.

rileyphone• 8 years ago

It's in ferret.org, apparently.

phoe-krk2• 8 years ago

ALL of the code seems to be stored inside the org-mode file, https://github.com/nakkaya/ferret/blob/master/ferret.org - which is the most unusual form of source code organization that I have ever seen.

Quequau• 8 years ago

Using org-mode for literate programming isn't entirely unheard of.

antt4• 8 years ago

There's singles of us!

If you want to extract it run M-x org-babel-tangle and you will end up with the usual source files and directories installed relative to the location of the org file.

I doubt there's a dozen people in the world that do it. But it is surprisingly useful and powerful when you get used to it. If anyone in Melbourne is interested in learning about this I have been toying with the idea of running a workshop on it.

I'm in the process of getting the detangle working for noweb mode. The current implementation fakes it with regex which force you to write code linearly instead of literately. But even if you can't detangle arbitrarily nested code it's magic to see changes in a source file appear in the right source code block.

eigenspace2• 8 years ago

I actually just started dong this a few days ago and I’m loving it so far. I have it configured so that every time I save, emacs runs org-tangle and all my code ends up in the proper directories but I never have to touch it there, I can just stay in org mode and keep different ‘files’ of code in different collapsible sections making moving around much easier!

enitihas• 8 years ago

Just curious, how does github manages to render org files so flawlessly, including embedded code snippets. I thought emacs was the only popular environment supporting org files.

omaranto2• 8 years ago

That's called literate programming. Maybe the most famous example is the source code for TeX, a single ~25,000 line file (http://tug.org/texlive/devsrc/Build/source/texk/web2c/tex.we...) that can be used to make a TeX compiler, or produce a book explaining the implementation.

nine_k• 8 years ago

There's a "building from sources" section on https://ferret-lang.org/, but I could not easily detect where the source is on github.

Update: It needs to be extracted from an org file, and by default Github renders the org file so that the source is not visible.

zellyn• 8 years ago

Do you not see all the source code in https://github.com/nakkaya/ferret/blob/master/ferret.org?

gvb• 8 years ago

Or click the "raw" button on the github source page.

https://raw.githubusercontent.com/nakkaya/ferret/master/ferr...

BrendanD• 8 years ago

https://ferret.pmel.noaa.gov/Ferret/

nanomonkey• 8 years ago

The first time I came across this it was touted as Clojure that compiled down to C++11. Now I'm seeing it listed as a generic lisp. I'm curious if that's due to the limitations of writing for embedded systems (using d-list instead of hash tables, memory management, etc.) or are there other deviations?

kimi• 8 years ago

IIRC it used to be a fairly complete reimplementation of Clojure. I toyed with the idea of using it to cross-compile to Golang.

nakkaya2• 8 years ago

You are right. It is due to limitation of writing for embedded systems. I try to keep everything as close to Clojure as possible but some stuff is just not possible on embedded systems or behave a little bit different.

bsder• 8 years ago

Given that this seems to be a transpiler, why go to C++ instead of C?

What feature of C++ does this need that is so compelling as to cut it off from use on straight C?

m1n1• 8 years ago

Maybe that's a solved problem so that was outside the scope/focus? https://isocpp.org/wiki/faq/compiler-dependencies#convert-to...

nakkaya2• 8 years ago

If I were to go with C I would have to reimplement OOP machinery required for an object system. OOP also makes memory management a non issue. Functions are first class citizens in Lisp so functors/lambdas makes it real easy to create closures. std::atomic combined with Clojure semantics makes sure there no race conditions. std::thread / std::future makes multi threaded programming much easier. Templates help with picking and choosing which components to include (i.e there are multiple memory managers to pick from.). etc. etc. Non of the above is essential and can be done in C but why bother, GCC/LLVM people are much better at this then I can be including platform specific tricks for different architectures. Modern C++ is very close to Lisp after all it only takes 6 passes over the Clojure code to generate C++ code. (Compiler makes more than 6 passes but others are for optimization.)

Ferret: a Lisp implementation for real time embedded control systems

Related Stories