cjlarose

I could be wrong, but my impression of the post was that it is not meant to be a novel solution for a hard problem, but rather a demonstration of an interesting technique on a simple enough problem that the problem doesn’t distract from the technique itself.

Does this technique apply if the dimension of the null space of the linear transformation is greater than 1? In other words, if there is more than 1 free variable, can you still use the Smith normal form of the matrix to find a bijection from the integers to the solution set?

Edit: related follow up: any chance this technique is a good fit for enumeration of [Magic Squares][0] of a given order?

[0]: https://en.wikipedia.org/wiki/Magic_square

[Illinoi's 4th congressional district][1] was called the "earmuff" district because of its usual shape. It joined two predominately latino communities with a narrow strip of the I-294.

But not all weirdly shaped districts are bad. Between the two latino communities in that area, there is a predominately African-American community. By joining two latino communities together into a single district, it ensured that they had a representative serving their interests. This district in particular was featured in [a recent LastWeekTonight episode][2].

[1]: https://en.wikipedia.org/wiki/Illinois%27s_4th_congressional... [2]: https://youtu.be/A-4dIImaodQ?t=684

AppFolio | Software Engineer | San Diego, CA & Santa Barbara, CA | VISA

We build SaaS B2B2Cs for SMBs in the property management and legal spaces. We work with Ruby on Rails & ES6 JavaScript, including React.

https://www.appfolioinc.com/jobs-openings

FWIW, if you configure AWS RDS for Multi-AZ support, you essentially get a black box "cloud database" with synchronous replication and automatic failover. You're right, though, in that you're still essentially being allocated a fixed-sized single-node deployment of your favorite RDBMS.

I think the "obvious solution" is just not super easy to implement. If you want ACID compliance as with traditional RDBMSs but in a auto-scaling, distributed setting, it's not going to happen. Early RDMSs were built with a single node in mind, and any database-as-a-service will have to make some compromises. DynamoDB gives you the flexibility of not having to worry about scaling, and even offer strongly consistent reads, but without support for transactions, for example.

Maybe someone who knows more about logic programming can correct me, but it seems that these are just imperative solutions to problems designed to be solved in a logical programming context.

For example, take a look at problem 2.07 from the original 99-problems for [Prolog][1] and compare it to the [Java][2] solution in the linked repo. In Prolog, you're defining relations, so with GCD defined, you can compute the GCD (g) given two integers a and b, but you can also compute possible values for b, given a and g, for example. The Java solution doesn't allow for anything like that.

So, given the README information, I expected to see the implementations in different language platforms utilize some prolog-esque logic programming library (like core.logic for Clojure), but that isn't the case.

[1]: https://sites.google.com/site/prologsite/prolog-problems/2 [2]: https://github.com/shekhargulati/99-problems/blob/master/jav...

Interestingly, arithmetic on the Mill CPU does this (at the machine level instead of at the language level). You can get modulo addition, saturating addition, widening addition, and excepting addition.

http://millcomputing.com/wiki/Instruction_Set_by_Category#Si...

I understand that macros are both the mechanism to generate code at compile-time as well as for generating code at runtime. But it doesn't look like the linked project does the latter. In fact, there are mentions in the README that indicate that there is no runtime for LISP/c at all:

> The way that LISP/c works is sort of tricky. It utilizes a lot of string manipulation and interpretation. It doesn't need to be insanely fast, though, because it's just dealing with code; the compiled result will not suffer from any slowness.

In other words, it seems that this project just allows you to generate C code from a LISP-like syntax, but doesn't allow you to `eval` during the execution of the resulting C program. There is no runtime representation of code as data as with other lisps.

I feel like besides powerful macro generation, the other big selling point of a lisp is that you can dynamically generate code at runtime, either by providing hooks into the compiler itself or by running the generated code through an interpreter. This project doesn't seem to do that at all. Does anyone know of any similar projects that do?

Make sure to check out the perfectly circular ones, too! http://goo.gl/zilq50

I stumbled upon gamma when I first starting looking into shaders--it's pretty incredible what it's doing. mikekchar is exactly right, I think, in thinking that lisp is a good candidate for creating what's described as embedded domain-specific languages (EDSLs). When I first explored writing my own shader for this project, I opted for doing it myself just so I could get a better understanding of what's happening under the covers, with the intention of maybe introducing gamma later. It ended up that my shader was super simple--just a for loop and some basic trig math, so it wasn't super necessary to migrate. But, from what I've heard, even mildly complex shaders can get out of hand quickly, so gamma and projects like it are super promising.

Author here! I experimented a bunch with different ways to calculate the plotted points. WebGL shaders outperformed everything by a mile, though it was weird dropping down into what's essentially a low level C-like language. Check it out https://github.com/cjlarose/de-jong/blob/master/src/de_jong/...

Uh oh. I don't have a VM up and ready, but I'll check it out when I do. Thanks for letting me know!

Yeah, so the application state is captured in the URL with throttling. The behavior isn't too different from Underscore/Lodash's throttle function (https://lodash.com/docs#throttle). Basically, you can click and drag the range sliders to update the visualization pretty rapidly. If I updated the URL with windows.history.pushState every time the state changed for a single keyframe, it would overload the history and be a pain to hit the "back" button. So instead, I throttle calls to pushState so it fires no more than every 500ms.

I think it might be too to do a write-up. I definitely learned a lot doing it!

I first found out about the de Jong attractor from a talk recently at the Clojure West conference. https://www.youtube.com/watch?v=vLlbEZt-3j0. I found a few videos around where people were animating between different plots of the attractor, but nothing interactive.

Written in Clojurescript using Om (React) and THREE.js. Code at https://github.com/cjlarose/de-jong

The author seems to criticize that the Java classes are named for how they're implemented, whereas the CoreFoundation ones are named for what they are instead. In Java, though, the convention (at least in the Collection library), is that the Interface name tells you what the thing is (List, Map, Set), and the class name tells you how it's implemented (ArrayList/LinkedList, HashMap/ConcurrentMap, HashSet/TreeSet).

Meanwhile, the Python 3 Wall of Superpowers is looking really good. 166/200 major watched projects are Python 3-compatible. https://python3wos.appspot.com

At the time of writing (September 2013), the JWT spec would have been only on it's 12th draft--it's had 19 follow-up drafts since then. It's possible that the author didn't know about them at all.