Sign in with Twitter

Username:

Occasional OCaml programmer

104 Following   2,765 Followers   1,827 Tweets

Joined Twitter 6/21/09

Reverse Tweets
Alternating between listening to the Hamilton album and Chernow's biography. It makes for quite an exciting cacophony in the brain.After complaining on VisualStudio, worth mentioning that I just downloaded @racketlang to a new computer and started coding in ~150 SECONDS.
Retweeted by Yaron MinskyOH: Outsiders think the learning curve for Haskell is a cliff; Haskellers know it's a cliff with @kmett on top building more cliff. #lca2016
Retweeted by Yaron Minsky
2/5
2016
A friendly reminder: if you want to move your project from camlp4 syntax extensions to ppx, there's a tool to help. https://t.co/fcmaSR1lmf
2/4
2016
@AlainFrisch not yet, but looking forward to it.Apparently, with camlp4 replaced by ppx, Core and friends build about twice as fast. More to be done, but nice progress nonetheless.
2/3
2016
A neat application of the expect test idea, to OCaml itself, courtesy of @dimenix https://t.co/NK0lhCBKsW
2/2
2016
@jordwalke @t0yv0 @granicz without the vdom, it's not obvious what to compute. But maybe I'm missing some better approach. @jordwalke @t0yv0 @granicz I don't quite see how. SAC let's you optimize a pure function. The vdom generation function is a natural here.If you can't say anything nice.¹ _____ ¹ Say it in a footnote.
Retweeted by Yaron Minsky @t0yv0 @granicz So we use an existing vdom to optimize the last bit. But physical equality is mostly preserved, so the diff should be fast. @t0yv0 @granicz In our case, trivial. We produce a Vdom.t Incr.t, and when that changes, new and old are diff'd and patch is applied to DOM.
1/31
2016
@t0yv0 Interesting! I'm curious what the websharper approach to incrementalization is.A new blog post on incremental computation and how it relates to (of all things) dynamic web apps. https://t.co/xNnjKuI7YH
1/30
2016
Had a great time with @Cambridge_Uni and @docker presenting on Unikernels and Multicore OCaml! Mind blown.
Retweeted by Yaron Minsky
1/28
2016
the stages of grief: 1. denial 2. preparation 3. commitment 4. acceptance ...wait no that's paxos, those are the stages of paxos
Retweeted by Yaron MinskyTachyons don't make it in until 5.0, since they break many existing APIs.And ephemerons make it into OCaml 4.03. Based named GC feature ever. https://t.co/iFoqikAyPz
1/27
2016
Spreadsheets are a wonderful thing, but the weirdly limited formula language has always struck me as deeply odd.Wow. Google Sheets lets you write formulas that return ranges. Next thing you know it will have lambda expressions. https://t.co/PHwg3Lo6PK @bendiken Done. @keleshev one could write the OCaml more concisely as well. But only in OCaml will the compiler flag the bug.
1/26
2016
I haven't posted a talk for awhile, so here's one I gave during our intern program about why Jane Street uses OCaml. https://t.co/7n3iPjxm17 @llaisdy Yes. @llaisdy there's one if you open Core.Std...
1/25
2016
Do some businessmen have trouble distinguishing irony from earnestness? 🤔 @pmarca https://t.co/3vUnAFhEcP
Retweeted by Yaron MinskyUnikernels are getting the hipster treatment. The way this is going OCaml will be the new Go. /cc @CloudiusSystems https://t.co/LeLKbClThn
Retweeted by Yaron MinskyIncrementalization is a key issue, but it complicates the story. But to appear simple, folk talk as if diff and patch are enough.It's interesting that descriptions of virtual dom frameworks shy away from explaining how the computation of the vdom is incrementalized.
1/22
2016
docker 2.0, written in OCaml?
Retweeted by Yaron MinskyI'm ridiculously excited to be joining the @docker family with the rest of Unikernel Systems; https://t.co/2BGGV4bQ0j
Retweeted by Yaron Minsky
1/21
2016
It's hard to find a happy balance between making tests realistic and deterministic.Or as some would call it, "taxes." https://t.co/DOVGN4OUNC
Retweeted by Yaron Minsky
1/19
2016
@leonidasfromxiv thanks! We'll get that fixed...I don't often find category theory to be helpful in thinking about code, but it is useful when showing something to my mathematician brother
1/16
2016
Ugh. https://t.co/vO43H2sifzAn unfortunate consequence of the popularity of https://t.co/7hjPVRULvL: it’s difficult to find help relating to actual stack overflows.
Retweeted by Yaron Minsky
1/13
2016
@jordwalke But such a model requires giving up some fine-grained control. @jordwalke How do you think about consistency? One thing that makes SAC nice is that it has a simple and general consistency model. @jordwalke But you wouldn't be able to rerender until the stabilize was complete. So maybe that's not useful to you. @jordwalke I could imagine doing this in incremental; basically making the stabilize interruptible. @jordwalke And lots of functional things are efficiently diffable, including records, variants, maps and sets. @jordwalke The thing I like about using SAC is that your model can be entirely "plain values", as long as those values are diffable. @jordwalke So how do you deal with context passed down from outer scopes? e.g., an outer component may track focus and inform inner things. @jordwalke So it sounds like there's a concept of a renderable component, and that component defines the granularity of incrementalization. @jordwalke Twitter is a hard medium for this kind of technical conversation, but, nonetheless.... @jordwalke I'm generally curious as to how the incrementalization strategy of React affects how you structure your model. @jordwalke the downside I see is the need to disassemble your closures to make dependencies explicit. It's somewhat anti-modular, sadly. @jordwalke I think I understand virtual-dom's thunks, or at least how Elm uses them. I'm wondering how different React is. @jordwalke do you have a pointer to a concise description of React's incrementalization strategy? Curious how it compares to Incremental.This is amazing: map of squirrel attacks on the power gird https://t.co/cfmsjY8f3c https://t.co/dewgSF2j4G
Retweeted by Yaron MinskyIt is done! The Flambda files just got merged into OCaml trunk. There's more work yet, but kudos to those who have gotten it this far.
1/12
2016
@matthewhammer @larsberg_ which lets you write val map_map : 'a Map.t Incr.t -> ('a Incr.t -> 'b Incr.t) -> 'b Map.t Incr.t efficiently @matthewhammer @larsberg_ And val map_join : 'a Incr.t Map.t Incr.t -> 'a Map.t with good asymptotic performance. @matthewhammer @larsberg_ So you can write functions with signatures like: val map_split : 'a Map.t Incr.t -> 'a Incr.t Map.t Incr.t @matthewhammer @larsberg_ I mean the ability to build incremental computations off of an ordinary diffable structure, like a map. @jordwalke We're working on something for Incremental. Should support anything with a diff and a patch. @tianyi yes, but variables are only at the leaves of the computation. You need something for flexibly building internal nodes too.Incremental needs primitives providing fine grained control over the inputs and outputs of a given node -- the analogue of Async's Ivar.Hello Lazyweb! anyone know of work on bridging the gap between self adjusting computations and ordinary diffable functional data structures?
1/11
2016
@das_kube Absolutely. Rarely is implementing map on top of return and bind the right choice. @jedws @smdiehl It's not like these specific names will change; but we should aim for a culture that values clarity and simplicity in naming @jedws @smdiehl Well, it's the relationship between them that counts. Also, being simple mnemonics is a plus, right? Hard is not a goal... @smdiehl @jedws mappable, applicable and bindable are decent, and better than what we have. Nothing here so exalted as to be hard to name. @jedws @smdiehl no disagreement there. @smdiehl @jedws If I called the Container interface Bergenoid, would you say the same thing? Madness can give useful semantic hints! @jedws @smdiehl Given the larger environment, these bad names are better than making up something new. But they're still bad names. @jedws Sure. But choosing these names in the first place was an expensive mistake. Maybe we can discourage similar mistakes in the future. @jedws @deech It's not like we need to learn just three concepts! This is a repeated game, and choosing helpful terms helps. @deech @jedws Prog. involves many subtle concepts. My experience is that names that give a gentle nudge in the right direction help a lot. @jedws My BA is in math. My brother's a mathematician. Math has a lot to do with how I code. But I don't want math's nomenclature. @smdiehl @jedws Naming can help or hurt. We spend a lot of time picking clear names, and have good experience that it helps others. @jedws Right, which is why Jane Street's code uses the term Monad and Applicative. But I'm sad to have been forced into it. @jedws I know, but it's a lame excuse. Mathematicians don't ape programmers, and programmers shouldn't do the reverse. @jakedonham little animations or transitions. @t0yv0 @samth That's just one case. There are endless other ones. Better I think to optimize the applicative subset, but keep bind around.It's surprising that there isn't a better way of getting element visibility out of the Dom, given how useful it seems.Another realization: Incremental's clock lets you efficiently express time-varying logic, so you can express easing outside the model type. @das_kube Easier to optimize from the library author's perspective, but harder for the programmer to optimize their program.The FP world is really bad at naming. It's a scandal that the names monad and applicative give no clue as to the relation between the two. @samth Indeed! Generally, the monad/applicative tradeoff is one where you take power from the user and give it to the implementer. @samth Bind lets the coder adjust optimize, e.g., "is_visible >>= function true -> dynamic_expensive_incr | false -> cheap_static_incr" @yminsky The lesson: applicative is not enough.Playing with Incremental, noticing how important bind is for optimizations, like cutting off updates for out-of-view nodes. @let_def incremental doesn't use finalizers or weak references for anything important. It refcounts from explicit observer nodes. @yminsky Or maybe it's only a comfortable idiom for people who are already comfortable with incrementality monads...Proof of concept of Incremental-in-the browser works! And it seems so far like a pretty comfortable idiom for specifying view functions.
1/9
2016
@jordwalke @kc_srk Interesting, and SAC won't help -- SAC has a simple approach to consistency that fixes all problems at once.
1/8
2016
@antonycourtney @jakedonham The space leak seems fundamental to the semantics, not an accident that an implementation can work around. @antonycourtney @jakedonham Question @ slides: when it says monadic FRP is "hard" to implement efficiently, should it say "impossible"? @seliopou Overjoyed to. Just tell me when you have time. @seliopou that's a slight exaggeration. You do need incremental or something like it to tie the pieces together. Still seems easier than d3. @seliopou but with diffable data structures, you get to code in a straight ahead style, and get incrementality almost for free.Core's Map.symmetric_diff is surprisingly useful. I think it's going to have a big role in how we build efficient web apps.
1/7
2016
@jakedonham That sounds right. @jakedonham The examples I've seen were large complex computations, much bigger than a web page. It gets worse with more nesting, maybe.Been having fun stuffing javascript scraped from stackoverflow into strings in my OCaml code and calling eval on them. Yee-haw! @jakedonham Not my experience. Ordinary imperative code seems a lot easier to me than thinking about exactly when that bind fires. @jakedonham The thing that makes it hard is that the start time for these computations is all very implicit. @jakedonham Yeah, the quiescing of unnecessary nodes definitely makes it worse. But we found it pretty confusing even without that.
1/6
2016
« Prev1234567

0