carson-katri

from geometry_script import *

# Constants
SAMPLES = 3

# Inputs
class ClothInputs(InputGroup):
    gravity: Vector = (0, 0, -0.5)
    friction: Vector = (0.999, 0.999, 0.999)
    stick_length: Float = 0.1

peterwang

;;; Clojure Macro-writing Macros step by step.
(ns my.macros)
;; => nil

;;;;;;;; ns and vars
*ns*
;; => #namespace[my.macros]

(def x 3)
;; => #'my.macros/x

dustingetz

This is probably going to be the next iteration of the declarative CRUD metamodel that powers Hyperfiddle. It's just a design sketch, the current metamodel in prod is different. Hyperfiddle is an easy way to make a CRUD app. Hyperfiddle is based on Datomic, a simple graph database with the goal of "enabling declarative data programming in applications."

CRUD UI definition

This extends Datomic pull syntax into something that composes in richer ways. The key idea is that Pull notation expresses implicit joins and thus can be used to declare data dependencies implicitly, without needing to name them. We also handle tempids, named transactions, and hyperlinks to other pages. We satisfy the hypermedia constraint, like HTML and the web.

{identity                                                   ; Pass through URL params to query
 [{:dustingetz/event-registration                           ; virtual attribute identif

tin2tin

#import the bpy module to access blender API
import bpy

#WARNING: this is written and tested for blender 2.79
#blender 2.8 and newer will likely have a different python API

#create a property group, this is REALLY needed so that operators
#AND the UI can access, display and expose it to the user to change
#in here we will have all properties(variables) that is neccessary
class CustomPropertyGroup(bpy.types.PropertyGroup):

borkdude

(ns reagent-blessed.core
  (:require
   [cljs.nodejs :as node :refer [require]]
   [react]
   [reagent.core :as r]))

(def v8 (js/require "v8"))
(.setFlagsFromString v8 "--no-use_strict")

(def blessed (node/require "blessed"))

bhb

Building a blockchain, assisted by Clojure spec

In an effort to gain at least a superficial understanding of the technical implementation of cryptocurrencies, I recently worked my way through "Learn Blockchains by Building One" using Clojure.

This was a good chance to experiment with using spec in new ways. At work, we primarily use spec to validate our global re-frame state and to validate data at system boundaries. For this project, I experimented with using instrumentation much more pervasively than I had done elsewhere.

This is not a guide to spec (there are already many excellent resources for this). Rather, it's an experience report exploring what went well, what is still missing, and quite a few unanswered questions for future research. If you have solutions for any of the problems I've presented, please let me know!

You don't need to know or care about blockchains to understand the code be

taylorwood

(ns playground.test
  (:require [clojure.spec.alpha :as s]
            [clojure.spec.gen.alpha :as sgen]
            [clojure.spec.test.alpha :as stest]
            [clojure.string :as cs]
            [clojure.walk :as walk]))

(def op-keys #{:and :or})

(s/def ::expression

apeckham

node_modules

sam95

Apache Kafka is a highly-scalable publish-subscribe messaging system that can serve as the data backbone in distributed applications. With Kafka’s Producer-Consumer model it becomes easy to implement multiple data consumers that do live monitoring as well persistent data storage for later analysis. You can assume that RabbitMQ is similar to Kafka, You do get an option for message-sending or Broadcasting. The installation process for OSX is as below.

1. The best way to install the latest version of the Kafka server on OS X and to keep it up to date is via Homebrew.

    brew search kafka
    brew install kafka 
   

2. The above commands will install a dependency called zookeeper which is required to run kafka. Start the zookeeper service.

zkserver start

dvingo

;; implementing a React component in pure cljs, no reagent necessary
;; using goog.object.extend to create a ES6 class that inherits from
;; React.Component

;; credit to @thheller

(defn MyReact [props context updater]
  (this-as this
           (js/React.Component.call this props context updater)))