I'm not sure these projects will ever "go anywhere," but at the very least I'm honing my craft as a programmer. I've learned so much, and I have so much more to learn.

---

[1]https://github.com/mrryanjohnston/CLIPSmqueue

The repo includes a fairly full test suite as well as examples that demonstrate multi-process communication between CLIPS rules engines.

My purpose in providing this library (and other CLIPS libraries I've released) is to expand the usecases in which CLIPS can be leveraged. Feedback welcome.

Comments URL: https://news.ycombinator.com/item?id=46434150

Points: 3

# Comments: 1

CLIPSQLite is a library for working with SQLite databases within CLIPS rules engines. It provides the basics like opening and closing connections, as well as more advanced ones like binding named variables to prepared statements and returning results as Facts and Instances.

Aside from being a lot of fun to create, my goal in making this is to open up the possibilities of using CLIPS in real world systems. Give it a look, and let me know what features you'd like to see added next!

Comments URL: https://news.ycombinator.com/item?id=45403416

Points: 4

# Comments: 0

I was inspired to write this after seeing a post[2] about 1wm on HN. I was struck by 1wm's (then called mwm) simplicity, so I dusted off a CLIPS X11 library I had started[3] and have been using CLIPS1wm as my main wm for the last few weeks on my Lubuntu vm.

Why CLIPS? Rules, Facts, and Instances with a Rete[4]-like algorithm give you caches, indexing, and pattern-matching out of the box rather than hand-rolled while loops. CLIPS is written in C, so it's really convenient for integrating with X11. Finally, CLIPS is more than fast enough for event-based wms; I've also used it for real-time performance-centered applications[5].

My goal in writing this is to help spread CLIPS widely, so give it a try, or even just review the implementation in the CLIPS1wm.multifield.clp, CLIPS1wm.fact.clp, and CLIPS1wm.instance.clp files.

Let me know what X11 features I should try to bring in next!

---

[1]: https://github.com/lslvr/1wm [2]: https://news.ycombinator.com/item?id=44634208 [3]: https://github.com/mrryanjohnston/CLIPSX11 [4]: https://en.wikipedia.org/wiki/Rete_algorithm [5]: https://ryjo.codes/tour-of-clipsraylib.html

Comments URL: https://news.ycombinator.com/item?id=45082424

Points: 4

# Comments: 0

This article caught my eye because it's focused on imperative programming, and I've been very focused on declarative vs imperative programming over the last few years. I implemented a version of your function in CLIPS, a Rules-based language that takes a declarative approach to code:

(defrule sum-is-0 (list $? ?first $? ?second $?) (test (= 0 (+ ?first ?second))) => (println TRUE))

(defrule sum-is-not-0 (not (and (list $? ?first $? ?second $?) (test (= 0 (+ ?first ?second))))) => (println FALSE))

(assert (list 1 0 2 -1)) (run) (exit)

The theorem you write in Lean to prove the function kind-of exists in CLIPS Rules; you define the conditions that must occur in order to execute the Right Hand Side of the Rule. Note that the above simply prints `TRUE` or `FALSE`; it is possible to write imperative `deffunction`s that return values in CLIPS, but I wanted to see if I could draw parallels for myself between Lean code and theorems. Here's a gist with the simple version and a slightly more robust version that describes the index at which the matching numbers appear: https://gist.github.com/mrryanjohnston/680deaee87533dfedc74b...

Thank you for writing this and for your work on Lean! This is a concept that's been circling in my head for a minute now, and I feel like this article has unlocked some level of understanding I was missing before.

Comments URL: https://news.ycombinator.com/item?id=43822764

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=43455620

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=42988077

Points: 3

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=42276852

Points: 3

# Comments: 0

  Location: Pittsburgh, Pa
  Remote: Yes
  Willing to relocate: No
  Technologies: CLIPS, Ruby (on Rails), Go, JavaScript, C, SQL
  Résumé: https://drive.google.com/file/d/1M-tC7qpehmsJfd3JBk3KtXEQ5wDJz89t
  Email: mrryanjohnston (at) gmail
  Website: https://ryjo.codes

If you haven't seen it, here's a past post that got some good traction on HN that you might find interesting: https://news.ycombinator.com/item?id=40201729

Comments URL: https://news.ycombinator.com/item?id=41428338

Points: 3

# Comments: 2

Comments URL: https://news.ycombinator.com/item?id=41034449

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=40979072

Points: 2

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=40976320

Points: 1

# Comments: 0

Comments URL: https://news.ycombinator.com/item?id=40972906

Points: 2

# Comments: 1

Comments URL: https://news.ycombinator.com/item?id=40971811

Points: 5

# Comments: 0

> Conventional programming languages, such as FORTRAN and C, are designed and optimized for the procedural manipulation of data (such as numbers and arrays). Humans, however, often solve complex problems using very abstract, symbolic approaches which are not well suited for implementation in conventional languages. Although abstract information can be modeled in these languages, considerable programming effort is required to transform the information to a format usable with procedural programming paradigms.

> One of the results of research in the area of artificial intelligence has been the development of techniques which allow the modeling of information at higher levels of abstraction. These techniques are embodied in languages or tools which allow programs to be built that closely resemble human logic in their implementation and are therefore easier to develop and maintain. These programs, which emulate human expertise in well defined problem domains, are called expert systems. The availability of expert system tools has greatly reduced the effort and cost involved in developing an expert system.