Fork me on GitHub

are auto-scaling groups not working in AWS us-west-2, or is it just me?


why do some articles give the impression taht type checking is difficult?


type checkig seems trivial if you just know the types of all the leaf node variables


then you just "go up the ast tree, and label all the intermedaite nodes"


@qqq sure, for primitive types, but it gets hard when you get into more complicated subjects. See stuff like covariance and contravariance for example


Not to mention stuff like this, what is the return type of this expression (if x 4 4.0)


@tbaldridge: oh, I was thikning (if x 23 "hello world") as illegal


@tbaldridge: if you create a series on type checking on top of the logic video series, I'll consider resubscribing to your video tutorials 🙂


Sadly, (happily?!?) type checking doesn't really interest me at all. Esp, considering that a good enough JIT doesn't care about static typing.


@tbaldridge : one more question regarding videos -- do you have any plans on extending the logic one into one on acl2 / jbob / the little prover / theorem provers ?


not at the moment.


I'm currently working on a custom rules engine (Rete network), so when I get somewhere with that code I'll probably do a set of videos on that, contrasting/comparing with logic engines.


@tbaldridge : I like rule engines. Let me know when you've released all the videos, so I can watch them all in 1 month. 🙂


@tbaldridge how do you estimate a Clara rule engine?


not sure I understand.


Do you mean what do I think of Clara?


yeah, sorry :))


np, Clara is pretty macro heavy, which has turned me away from it in the past. Also, I'm not entirely sure it's an immutable rules engine?


It's hard to tell from the docs if inserting a new fact modifies the existing engine or returns a "new" engine. From what I can tell it's mutable, which I'd also like to see done a bit differently


Also, I don't like learning DSLs, so I'd prefer a engine that used an existing syntax. In my experiments I'm using Datomic's Datalog


hmm, interesting. is it open source? ( custom rule engine)


Well it's only on my local HDD at the moment, lol


It's more like I've spent a few weeks reading stuff and said "heh I can build this" and in the few Fridays I've spent working on it I have something that can ingest Datomic transactions and fire rules when they apply.


All that is about 200 lines of super hacky code.


So yeah, I'd like to OSS it or something, I'm not sure what I'm going to do with it. But it's something I've needed more than once on a client's project, so we'll see.


What does interest me though about the subject of rules engines is that they tend to be a different way of projecting the same problem a logic engine solves. In one (logic engine), the data is static and you crawl the data from different ways.


In the other your query is static and you flow data through the query.


I'm interested about rule engine cause we have anti-fraud project in our bank. There are so many business rules and conditions to detect fraud/not fraud that put them in usual Clojure/Java code is a nightmare. rules engines seems to be a solution for that problem. I'm playing a bit with Clara right now . But I'm newbie in this topic


@tbaldridge : so 'rule engines' == 'streaming queries from db land' ?


@qqq yes, in a sense, you take a static set of "queries" and then feed it a bunch of facts (think Datomic tuples and transactions. The engine then lets you know when rules return new results, or a old result stops being true


It fits really well when you're in a situation where you feel like you need to re-run a bunch of queries every time the DB changes.


The downside is, if you want to add a new rule you almost have to toss out the old engine and re-ingest every fact in your database


yeah, it does seem like "keep track of when something is no longer true" == you have to build some data structure which stores the history


this sounds very cool, looking forward to your series on this


Good starting place for anyone who's interested:


@tbaldridge : I feel like om/next, re-frame, and datascript are sorta converging towards this, but for some reason no one's fully done this yet


a UI is basically static queries + streaming data (user input + network input)


Exactly! I've been thinking the same thing recently


esp with Datascript + these UI libs, why are we re-runing all our UI queries everytime someone transacts a new datom?