erickt

Stepping on each other's toes is just what happens with large projects. There are tools to help deal with merge conflicts so I don't think you should hold yourself back. OpenSSL needs all the eyes it can get right now.

It was talked about in our first SF Bay Area rust meeetup:

http://www.meetup.com/Rust-Bay-Area/events/143439552/

If I recall correctly, Skylight hooks into the ruby interpreter to do real time performance monitoring for Rails apps. They felt they couldn't get the performance they needed out of pure ruby, and felt that writing their hooks in Rust would be safer than in C. You can see Yehuda's presentation here. It's about an hour and 10 minutes in:

https://air.mozilla.org/sprocketnes-practical-systems-progra...

Yep, you are right. I just mailed rust-dev an announcement of the new Hash framework:

https://mail.mozilla.org/pipermail/rust-dev/2014-February/00...

You're right, we should mention it. Thanks for catching this. I filed a bug ticket to add some language about our performance goals:

https://github.com/mozilla/rust/issues/11174

Actually, the ZeroMQ compatibility layer was recently cut from nanomsg:

http://www.freelists.org/post/nanomsg/0MQ-compatibility-libr...

I love rust, but we have not yet finalized the syntax and the semantics yet, so it'd be risky to write mission critical things in it. Our plan is to hit 1.0 by the end of the year.

That said, rust has been written in rust, and every commit is tested against our test suite on Linux, OS X, BSD, and Windows. So while the language itself may be changing, any code you write in it at a given point in time should work. It'll just take some (small) effort to keep that code in sync with the compiler.

So if you are able to handle that risk, we'd love to have you try it out. It'd really help us find the warts in the language/stdlib before we lock in 1.0.

+foo is an old deprecated feature called a mode that is finally just about to be removed. Because the compiler is written in rust, it can take some time for deprecated things to be fully removed from the language.

Modes were supposed to give hints to the compiler whether or not to implicitly copy or move a value into a function, but it was buggy and confusing. So we replaced it with always moving for unique types, and always copying for reference counted types.

We do have a pretty printer that we're planning on growing into a gofmt-like tool, but we still have a ways to go with it before we will be comfortable using it in an automatic fashion like Go.

There is not support for this at the moment, but one of core developers mentions one approach for starting to address this need in:

http://smallcultfollowing.com/babysteps/blog/2013/04/02/asso...

That sounds great. We do have a basic package management system (https://github.com/mozilla/cargo-central), so it'll be easy to get anything you write into the community.

Oh boy I can't count. That criteria is a little tongue-in-cheek. Basically the core developers decided saving those extra three characters wasn't worth it. We implicitly return the last expression, so "return" is typically only used for an early exit. Therefore it's more approachable to new users, and pretty rare so it doesn't add much clutter.

We like brevity in our keywords, but we felt that "ret" was taking things a little too far. "return" met our 5-characters-max criteria, so we switched.

edit: Ho ho ho, I can't count. And we don't really have a 5-character-max criteria, but we do prefer shorter keywords.

My favorite is the faster regex engine:

https://issues.apache.org/jira/browse/LUCENE-1606

The elasticsearch folks were waiting for that before exposing regexes to the world.

I have been working on a web framework stack: http://github.com/erickt/mre

Mozilla is using rust for a new prototype engine called servo: https://github.com/mozilla/servo

And unql: http://www.unqlspec.org/display/UnQL/Home

Technically yes, but you can use elasticsearch as a distributed key-value store. I use it in production and it works amazingly well for me. Yes, searches may return stale data (one second old by default) but that is not much of a problem in my app.

If you weren't aware, the This American Life business team spun off to form Planet Money, which is also an amazing show:

http://www.npr.org/blogs/money

10.3 should work. Go to the Preferences, then Store, and select Automatic Downloads for Music/Apps/Books. Also, you can go to the Apple Store and under Quick Links, you'll find a Purchased link. That'll let you re-download any Music/Apps/Books. It's not really cloud-y yet, but it's a start.

I think reading strace's output was a great experiment, but I don't think it's really that necessary. Most programs have some way of spitting out the dependencies, and some others follow pretty standard rules for file generation. For instance, ocaml optional interface files generate a .cmi file from a .mli file, and implementation files generate a .cmo file from a .ml file. However, if no .mli file exists, compiling the .ml file will also generate a .cmi file.

It can be a pain, but it's really not that hard to handle if your build system provides a way to abstract out build patterns.

I agree, I feel like redo isn't going far enough. I'm not sure if I'm missing something, but semantically this is very similar to make, even though it looks like it is a better syntax.

Of course, I'm completely biased :) I have my own build system called fbuild (http://github.com/erickt/fbuild) that's conceptually similar to fabricate/memoize. There's also mem (http://srp.github.com/mem/getting-started.html) and wonderbuild (http://retropaganda.info/~bohan/work/sf/psycle/branches/boha... -- although that link appears to be broken at the moment) if you're interested in some other projects that have similar roots.

I believe the key insight that we all independently made is that we can use the procedural execution stack for the dependency tree, and cache the function arguments and results to avoid work duplication. I believe this helps someone reason about what's going on in the build system compared to the declarative make systems because you can easily trace the inputs and outputs of some dependency.

Furthermore, you can do some pretty interesting things with this model if you push this idea. It's pretty simple to do integrated configuration and building. For instance in fbuild, I can do (fbuild uses python3 for it's host language):

    import fbuild.builders.c
    import fbuild.config.c.linux

    def build(ctx):
        # make a c compiler.
        builder = fbuild.builders.c.guess_static(ctx)

        # check if the system supports epoll
        if fbuild.config.c.linux.sys_epoll_h(builder).header:
            use_epoll = True
        else:
            use_epoll = False

        builder.build_exe('foo', ['foo.c'],
            defines=['USE_EPOLL' if use_epoll else 'USE_SELECT'])

I don't think many of the new build systems have looked into the configuration issue yet, which is a shame. I'd love to get some more ideas out there.

Thanks, I didn't know they were finally adding search to Safari either.

I also have my own build system, fbuild:

http://felix-lang.org/tags/fbuild

That has some basic support for Java. I'm using Python3 for my dsl. Here's a dummy example of how to use it (from http://github.com/erickt/fbuild/tree/master/examples/java):

    import fbuild.builders.java
    
    def build(ctx):
        java = fbuild.builders.java.Builder(ctx)
    
        lib = java.build_lib('lib.jar', ['World.java'])
        exe = java.build_lib('exe.jar', ['HelloWorld.java'], classpaths=[lib])

        ctx.logger.log(' * running %s:' % exe)
        java.run_class('HelloWorld', classpaths=[lib, exe])

I haven't had much demand for Java support, but it probably wouldn't be that difficult to extend it to download from a maven repository.