2,885 reputation
1015
bio website jelv.is
location Berkeley, CA
age 21
visits member for 3 years, 8 months
seen Jul 23 at 22:53

I am a student interested in programming languages, functional programming, program synthesis, type theory, universal algebra and startups (not necessarily in that order!). In the near future, I want to combine as many of these as possible.

I am currently an undergraduate researcher at the Berkeley ParLab, working on program synthesis. This past summer, I was a tech intern at Jane Street Capital, brazenly using OCaml in the real world. Right now, I'm leading a meetup group about type theory; you can see the slides here or just show up to the next on if you live near SF ;).

I am always happy to chat: my email is tikhon@jelv.is

GitHub: http://github.com/TikhonJelvis

Website: http://jelv.is


Jul
20
comment Does javascript support numerically indexed arrays with a more optimized algorithm than an associative array?
@supercat: I'm not entirely sure exactly how slice is defined in the standard, but I suspect you're right in that it has to work with all the whole-number keys. Perhaps it also depends on the length property of the array.
Jul
20
comment Does javascript support numerically indexed arrays with a more optimized algorithm than an associative array?
@supercat: That depends on which JavaScript implementation you use. It's not part of the standard, so you can't necessarily rely on it. It's probably true for most browsers at the moment, but they might change it in the future—after all, they changed to this implementation from just returning every key in the order it was added recently, I believe.
Jun
18
comment Why are most functional programming languages also interpreted languages?
@JörgWMittag: Ah, so mixed mode is basically JIT.
Jun
18
comment Why are most functional programming languages also interpreted languages?
@JörgWMittag: Well, you have to compile to the bytecode first. Perhaps I misunderstood what you meant by mixed-mode though. The bytecode compiler is used by camlp4, but that's a bit of a historical accident and makes it slow, so they're not using it for their new "extension point" system. Mostly, the bytecode compiler is useful for portability and simplicity: for example, it's used by js_of_ocaml to compile to JavaScript. I think it's also used for the REPL.
Jun
18
comment Dealing with state problems in functional programming
Except perhaps for the database example, those problems are not inherently stateful. For example, for GUI programming, you're really using mutable state as a poor, implicit model of time; functional reactive programming lets you model time explicitly without relying on state by providing streams of events you can combine.
Jun
18
comment Why are most functional programming languages also interpreted languages?
OCaml has something like two implementations in one: a normal compiler and a bytecode compiler. The first is a normal optimizing compiler while the second is more a mixed-mode system with a bytecode interpreter. They're shipped together, but are separate backends.
Jun
3
comment What is the “Free Monad + Interpreter” pattern?
@BenjaminHodgson: Boyd is completely right. I wouldn't worry about it too much unless you're just curious. Dan Piponi gave a great talk about what "free" means at BayHac, which is worth a look. Try following along with his slides because the visual in the video is completely useless.
Jan
28
comment Why do dynamic languages make it more difficult to maintain large codebases?
@JörgWMittag: It doesn't seem to have overloaded literals the way Haskell does: it just has a few nested types of numbers. For example, you can't add your own numeric types, especially if they don't fit into the existing hierarchy. I still don't see any way to do this without either having explicit annotations or using typeclasses and inference. Besides numbers, consider things like Read which also relies on typeclases. My real point is that type systems do not just reject illegal programs. With type inference, they can make programs that would be underspecified without types work.
Jan
27
comment Why do dynamic languages make it more difficult to maintain large codebases?
A type system can actually make a language more expressive. Consider Haskell typeclasses--they enable really useful things like overloaded literals that are difficult if not impossible to replicate in other languages.
Jan
27
comment Why do dynamic languages make it more difficult to maintain large codebases?
@ThiagoSilva: Monads are not an example of complexity per se. Many people find them hard to learn, but as abstractions go they are quite simple--the difficulty is that they are also quite abstract. In fact, monads often simplify a design by making it more explicit: they just highlight things which are magical and unacknowledged in other languages. And Norvig's design-pattern article is not relevant to statically typed functional languages at all; it's not a comment about static typing in general but rather about Java-style type systems (which we can all agree are a mess).
Oct
25
comment What are the safety benefits of a type system?
Another great example for what type systems can verify: units of measure. This even includes automatically converting between compatible units like feet and meters!
Jun
15
comment When is it a good time to reason about performance in Haskell?
@MasonWheeler: He's most likely talking about asymptotic complexity. The constant factors are an implementation issue. Moreover, even if both programs terminate, the non-strict one could do significantly less work: consider all even [1..1e10] for both a strict and a lazy version of all. The compiler also has more leeway for choosing the order of evaluation in a language like Haskell with things like loop fusion.
Apr
24
comment Why does Haskell have built-in “if/then/else” instead of defining it as a simple library function?
I don't think the inlining is an actual issue. My understanding is that GHC is already exceptionally good at inlining small functions, because it's just such a common pattern in Haskell.
Mar
20
comment What's the next level of abstraction?
"Duck typing" (at least as you describe) is not really novel or limited to dynamically typed languages; it's been around for a long time in statically typed languages as "structural sub-typing", best seen in OCaml.
Mar
20
comment What's the next level of abstraction?
FRP is great, but it deals with a fairly specific sort of programming (namely reactive programming). It is not very good for modelling other sorts of programs. However, the more general sort of programming it represents--writing your code in terms of algebras--is a good candidate for a new level of abstraction.
Mar
19
comment CoffeeScript and Named Functions
@WinstonEwert: It matters because CoffeeScript is so close to JavaScript. After all, the "golden rule" is: "It's just JavaScript".
Mar
19
comment CoffeeScript and Named Functions
@skizeey: Good points, thanks.
Feb
16
comment How does if/else work internally in all programming languages?
I think that "simplifying" by limiting your discussion to C-like languages is a disservice, especially to beginners: it's very useful to know about alternatives and we should encourage people to explore other options.
Feb
12
comment Inspirational software for end-users written in Haskell?
@quant_dev: I'm not quite sure what you mean with that comment, partly because this question did get closed, but largely because this site does not seem biased towards FP at all.
Feb
5
comment What's the progress on Haskell records?
The other issue is that if you add a new record system, you can either get rid of the current one, which would be a breaking change, or have two record systems simultaneously, which would be a mess. I think the a.b issue is less important because A.b already means something different from A . b (thanks to the module system). Sure it's a breaking change, but it's not a particularly bad one.