サクサク読めて、アプリ限定の機能も多数!
トップへ戻る
災害への備え
blog.janestreet.com
OCaml with Jane Street extensions is available from our public opam repo. Only a slice of the features described in this series are currently implemented. Rust, OCaml, and Resource Management Coming from OCaml, the Rust programming language has many appealing features. Rust’s system for tracking lifetime and ownership allows users to safely express patterns that are awkward in OCaml, such as: Stac
At Jane Street we use a pattern/library called “expect tests” that makes test-writing feel like a REPL session, or like exploratory programming in a Jupyter notebook—with feedback cycles so fast and joyful that it feels almost tactile. Having used them for some time now this is the only way I’d ever want to write tests. Other languages call these “snapshot” tests—see for example Rust’s expect-test
Posts about interviewing at Jane Street and our internship program Intel Processor Trace is a hardware technology that can record all program execution flow along with timing information accurate to around 30ns. As far as I can tell almost nobody uses it, seemingly because capturing the data is tricky and, without any visualization tools, you’re forced to read enormous text dumps. Magic-trace is a
Last year we held a machine learning seminar in our London office, which was an opportunity to reproduce some classical deep learning results with a nice twist: we used OCaml as a programming language rather than Python. This allowed us to train models defined in a functional way in OCaml on a GPU using TensorFlow. Specifically we looked at a computer vision application, Neural Style Transfer, and
With the external release of OCaml 4.07.0 imminent, we in Jane Street’s Tools & Compilers group have been planning what we want to work on for inclusion in OCaml 4.08. These days OCaml uses (or at least attempts) a time-based release process with releases scheduled every 6 months. We’re trying to avoid rushing in changes at the last minute – as we’ve been prone to do in the past – so this list is
There are abundant resources online trying to scare programmers away from using shell scripts. Most of them, if anything, succeed in convincing the reader to blindly put something that resembles at the top of their scripts. Let’s focus on the “-e” flag. What does this do? Well, here are descriptions of this flag from the first two results on Google for “writing safe bash scripts”: “If a command fa
OCaml 4.03 is branched and a first release candidate is imminent, so it seems like a good time to take stock of what’s coming. This post will focus on just one of those features: Flambda, a new IR (intermediate representation) in the depths of the compiler designed to allow for better inlining, paired with a set of optimizations leveraging that IR. Why inlining matters If your expectations about i
In my last post, I gave some simple examples showing how you could use self adjusting computations, or SAC, as embodied by our Incremental library, to incrementalize the computation of virtual dom nodes. In this post, I’d like to discuss how we can extend this approach to more realistic scales, and some of the extensions to Incremental itself that are required to get there. Along the way, we’ll di
I’ve been thinking recently about how to structure dynamic web applications, and in particular about the role that incremental computation should play. In this post, I’d like to outline an approach we’ve been experimenting with internally which uses Incremental, a general purpose library for building so-called self adjusting computations. Self adjusting computations are essentially graph-structure
Here’s a post from a talk I gave this last summer during our internship program about why we use OCaml. It spends a lot of time on how OCaml fits into the space of programming language designs, and why we think OCaml is in a real sweet spot in that design space, especially for the kind of work we do at Jane Street. Warning: it’s a very informal talk, with lots of questions and answers from the aud
I’m pleased to announce the release of Incremental (well commented mli here), a powerful library for building self-adjusting computations, i.e., computations that can be updated efficiently when their inputs change. At its simplest, you can think of a self-adjusting computation as a fancy spreadsheet. In a spreadsheet, each cell contains either simple data, or an equation that describes how the va
Posts about interviewing at Jane Street and our internship program We’ve been doing a bunch of work recently on improving the responsiveness of OCaml’s garbage collector. I thought it would be worth discussing these developments publicly to see if there was any useful feedback to be had on the ideas that we’re investigating. The basic problem is a well-known one: GCs can introduce unpredictable pa
When GADTs (Generalized Algebraic Data Types) landed in OCaml, I wasn’t particularly happy about it. I assumed that it was the kind of nonsense you get when you let compiler writers design your programming language. Which is to say that the standard GADT examples all seem to be about the kinds of things that compiler writers do, like embed domain-specific languages or build typed abstract-syntax t
If you were teaching a programming course, what language would you teach it in? I like this question because it has any number of good answers, each quite different from the other, and each emblematic of a different approach to what programming is about. The first formal programming class I took was COS 217 at Princeton, taught by the excellent (and at the time, I thought, terrifying) Anne Rogers.
Posts about interviewing at Jane Street and our internship program Software Engineering Interviews at Jane Street Welcome to our version of the “Technical Interviews at insert your company here” post. This topic has been covered by a lot of people already, so I’m going to do my best to not repeat all of the copious advice already out there. Interviewing, for both the interviewers and the interview
Almost every programming language uses 64-bit integers on typical modern Intel machines. OCaml uses a special 63-bit representation. How does it affect OCaml? OCaml int memory representation Most of OCaml’s types are in memory represented as a header followed by data. The header is a 64-bit integer containing the length of the data and a tag. Tag is a rough classification of the type. The only OCa
This is the last in my series of posts about new features in OCaml 4.02. So far, I’ve discussed how OCaml is getting more like Lisp because of extension points, how module aliases will massively speed up compilation of Core and similar libraries, and how you can simplify your error handling by catching exceptions with match statements. Below, I’ve summarized the other features that strike me as wo
This post is meant to be an introduction to Core_bench, our micro-benchmarking library for OCaml. Core_bench is similar to Haskell’s micro-benchmarking library, Criterion, in that it serves the same overall purpose. It is however not a direct port of Criterion to OCaml, but instead employs a different approach to estimating costs that we think yields better results. We think the result is a benchm
(OCaml 4.02 is entering a feature freeze, which makes it a good time to stop and take a look at what to expect for this release. This is the first of a few blog pots where I’ll describe the features that strike me as notable.) OCaml’s metaprogramming story is kind of messy. The good news is that OCaml has an effective metaprogramming system. It’s called camlp4, and before complaining about it, I w
As anyone who has looked into functional reactive programming (FRP) knows, there are lots of competing approaches to it, and not a lot of conceptual clarity about how they relate to each other. In this post, I’ll try to shed some light, and in particular give you some guide posts for understanding how the different versions of FRP relate to each other. Plus, I’ll show some connections to a similar
Jul 22, 2024 | 3 min read Visualizing piecewise linear neural networks Neural networks are often thought of as opaque, black-box function approximators, but theoretical tools let us describe and visualize their behavior. In particular, let’s study...
このページを最初にブックマークしてみませんか?
『Jane Street Tech Blog』の新着エントリーを見る
j次のブックマーク
k前のブックマーク
lあとで読む
eコメント一覧を開く
oページを開く