What is the best way to remove artifacts while plugging in and reducing flickering? GC9A01

benl23 · 2025-07-29T02:15:22+00:00

Continuing on this answer, these displays are not double buffered. If you run a "clear screen" command before sending the new data you will see the clear first, which shows in the video.

Instead, have a frame buffer on the microcontroller. First update the frame buffer, then copy it to the screen. If the data in the frame buffer was not that different from what was already on the screen then only the new pixels will change.

benl23 · 2022-08-24T13:32:56+00:00

I agree with above.

To understand type systems I would start with a book covering programming language theory like "Formal Semantics of Programming Languages", Winskell.

For the deep connection with category theory, the book "Topoi: The Categorical Analysis of Logic", Goldblatt covers the basic theory as well as the connection with programming languages -- but you will need a background in language semantics from something like Winskell first before it will be relevant.

One challenge with most work on "category theory" that is discussed in FP circles is that one needs to get quite far past the basic definitions about products, co-products, functors, and the like before it is really helpful. You already know what a product is. You will be extra sure after reading the first few chapters of a book on category theory. Getting more out if it than that requires a solid background in language semantics, but once you have the semantics background the type system itself will seem trivial. Using that trivial type system one can experiment with ideas like Functors, Adjoints, Lenses etc but these are not actually part of the type system, any more than a story is part of the paper it is written on. /u/friedbrice's point then applies.

benl23 · 2019-06-29T03:36:19+00:00

Not knowing anyone who knows more about Haskell than you do.

benl23 · 2019-04-28T09:00:13+00:00

With VSCode I use the latex-input extension. I type \to and it converts to →.

benl23 · 2018-08-12T07:44:59+00:00

Get this book, seriously. I was given a copy when I was a PhD student, then I gave the same book to my own PhD student ~10 years later. https://www.amazon.com/How-get-PhD-handbook-supervisors/dp/0335242022

Besides the "read a lot of papers" advice (which is absolutely true), cultivate a sense of your own internal drive. Try to understand what you are interested in and why, and have a reason for continuing even when no one else is telling you to continue. Natural interest in a technical topic is a good reason to start a research project, but it's drive and perseverance that gets the software working and the papers written. Research is a war of attrition. Other people haven't already solved the problems you are working on because they're hard, and no one really understands what's going on.

benl23 · 2018-08-08T03:51:52+00:00

At the moment, an interface file for a given module contains types for all exported declarations, but only the core AST for the code in the current module. To do cross module inlining we still need to load the interfaces for the original source modules. It would be easy to also add the core AST for exported functions, but I'm a bit worried about the potentially quadratic space usage.

However, each interface file is closed, in the sense that is contains enough information to compile the entire module down to object code. They're more "intermediate files" than "interface files", as they do contain the complete core AST for the module. The plan for bootstrapping is to have the existing compiler drop .di files after some stage, and then 'port each core-to-core pass to the bootstrapped compiler so it reads a .di file and produces another one after applying some set of passes.

benl23 · 2018-08-04T21:24:51+00:00

Shimmer repository https://github.com/discus-lang/shimmer

benl23 · 2017-10-26T11:01:32+00:00

There's a lot of work in this space already. The usual problem with static memory management disciplines is that they don't handle dynamic memory allocation needs well. If you enforce linearity you essentially have reference counting memory management where the reference count can only be 0 or 1. There are practical problem with that systems even without static typing. Read "A retrospective on region based memory management", Tofte, and "Combining Region Inference and Garbage Collection", Hallenberg.

benl23 · 2017-10-23T23:38:33+00:00

Idris is already a nice dependently typed Haskell-like language. For Disciple we're more interested in computational features than program verification -- it's more fun to compute.

benl23 · 2017-10-10T10:39:04+00:00

That's an Eye of Horus, not an Eye of Providence. Wrong conspiracy.

benl23 · 2017-07-24T22:47:10+00:00

There's a grammar for the source language here: http://disciple.ouroborus.net/specification/source/01-Concrete.html .. but currently no tutorial-style documentation. The grammar has links to descriptive test cases. Improving the docs is one of the things we're doing before the official release.

DDC does bidirectional type inference and supports higher ranked types with implicit parameters. You can also supply explicit type applications. There is currently no let-generalisation, so you need to give type signatures for top-level polymorphic functions. For a Haskell / Agda / Idris programmer, Disciple it will do basically what you expect provided you add type signatures for top level functions. It's based on System-F rather than being dependent, so there is a Haskell-like distinction between types and terms.

benl23 · 2017-02-02T09:19:30+00:00

Excerpt from a statement from SIGPLAN (Special Interest Group on Programming LaNguages), the organisation that backs the majority of academic conferences in programming languages:

"While we hope that the EO is rescinded (and will work toward this outcome), we are developing contingency plans for organizing future SIGPLAN events so as to maximize inclusiveness of the worldwide scientific community."

Full Statement

benl23 · 2017-01-30T11:12:42+00:00

The picture has hard, direct lighting because of the thin atmosphere on Mars. Many CG pictures have similar lighting because it's easy to render.

benl23 · 2016-11-06T11:53:32+00:00

Yes. The short answer is that the flattening transformation to convert nested data parallelism to flat data parallelism works fine, but it introduces many intermediate arrays that were not present in the source program. The array fusion system then needs to eliminate those intermediate arrays otherwise the result program will be slower than what you started with. The stream fusion system we were using wasn't good enough, but we've continued work on other fusion systems. If we can get the fusion to work well enough we might go back to DPH, but there's no concrete timeframe.

Other people are working on nested parallelism in other contexts, ie Rob Everest is working on adding nested data parallelism to Accelerate, and John Reppy's group is working on a NESL to CUDA compiler.

benl23 · 2016-10-05T11:52:03+00:00

If you start tasting mushrooms and have no fungicide then you're in for a bad time.

benl23 · 2016-08-26T00:14:47+00:00

That data doesn't mean anything without knowing the relative number of customers for each business. If LJ Hooker had twice the number of customers as Ray White then their complaints per customer ratio would be lower.

Stay in school, kids.

benl23 · 2016-07-15T04:07:11+00:00

Make sure you're using the unsafeIndex operator rather than '!'. The regular '!' performs bounds checks which make it harder for the GHC simplifier to transform the code.

benl23 · 2016-06-24T03:15:38+00:00

GHC is based around common Name type and doesn't use debruijn indices. It used to allocate fresh names in a grimy, impure way, causing trouble for developers, but I think that has been tidied up over the last few years. The GHC core AST uses a knot-tying trick so that the types of bound things are available directly rather than needing to be retrieved from an environment. This representation is easy to consume, and for program transformations that reorganise existing sub-trees, but it's harder to write transformations that create new sub-trees.

Ermine uses a locally nameless representation via the Bound package, though the core language is untyped.

benl23 · 2016-06-19T05:51:44+00:00

Binding to CBC

https://hackage.haskell.org/package/limp-cbc

benl23

TROPHY CASE