HNHacker News
TopNewBestAskShowJobs

blaenk

124 karma · joined December 5, 2010

jorge.israel.p@gmail.com • @blaenk • http://www.jip.dev

[ my public key: https://keybase.io/blaenk; my proof: https://keybase.io/blaenk/sigs/L9s0eBs0lnDYIyfgyZbxpmrBNkMBiPlHi6tEUtNcsDg ]

submissionscomments
blaenk··on Org-Mode for Writing: Structure and Focus
I'm curious what things from Evil aren't "enough like vim" for you. I switched over after nearly a decade of loving vim and I feel like it's a better vim than vim itself, shockingly, in the sense that, for example, it's very easy to define new operators, motions, text objects, etc., and that the more popular/essential vim plugins had Evil implementations that worked better than the vim originals. Very rarely did I encounter discrepancies, and when I did, I reported it and it was resolved right away. Evil is an amazing project.
blaenk··on Neon: Node plus Rust
Neon is for creating native Node modules in rust, which are libraries that use the Node addon API [1].

node-ffi seems to be for adding a bridge between an existing non-Node module dynamic library and node, which at the very least seems to incur some non-negligible overhead; see the "Call Overhead" section of your link.

[1]: https://nodejs.org/api/addons.html

blaenk··on Announcing Rust 1.3
You shouldn't have to change the path separators; Windows supports '/' as well, if you're working with paths. If there's something else you're doing, you might benefit from something like http://doc.rust-lang.org/std/path/constant.MAIN_SEPARATOR.ht...
blaenk··on What's new in Magit 2.x
TL;DR: Watch this video: the stated reasons for switching are very similar to my own. It wasn't until I watched this video and read the book that I took the plunge to switch to emacs. It was the fact that with emacs I could have vim _plus_ much more and better functionality. https://www.youtube.com/watch?v=JWD1Fpdd4Pc

I'll have to write a blog post about it sometime, but basically while I absolutely _love_ the vim 'editing interface', that is, not the GUI, but the modal editing, the bindings, motions, objects, relative line numbers, and so on, everything else aside from that, primarily plugins, always felt like ad-hoc hacks to me. I've contributed to a couple of vim plugins so I've seen it first hand, to the point where plugin authors I've worked with have expressed feelings of wanting to switch to emacs to just make things easier. Indeed, some have, such as the vim-airline author [ http://bling.github.io/blog/2013/10/27/emacs-as-my-leader-vi... ].

Whereas plugins in vim oftentimes gave me the impression that they were stopgaps and hacky workarounds to get vim to do something it wasn't meant to do, emacs packages feel very natural, comprehensive, and well designed. Just take this article for example. As awesome as vim-fugitive is for vim, I feel that it's good _for being a vim plugin_, but it has _nothing_ on the equivalent on emacs: magit. Take a look at it's comprehensive documentation: http://magit.vc/ Or flycheck's [ http://www.flycheck.org/ ] documentation here [ http://www.flycheck.org/manual/latest/index.html ]

It seems like everyone puts up with everything else about vim just to have the good parts of vim that are generally very poorly emulated by other editors. The evil package for emacs changed that for me, as it's the most faithful vim emulator I've seen. Now I have a superset of vim; the vim that I love in an environment that is _much_ more suitable for my development workflow: magit, error checking, tags, searching, and more.

If you're just a vim user, you probably don't really think about or realize what you're missing out on by not using emacs. One of my favorite things about emacs that the book really emphasizes is that it is completely self-documenting. Every function, every key binding, every command, every variable, everything is documented and easy to find. Vim of course has `:help` as well, but emac's documentation is on an entirely different level. I can press `C-h k` for example, then press a binding on my keyboard, and it'll tell me what command I have it bound to, what that command does, and it'll have a link to the source code for that command that opens in emacs with syntax highlighting and everything. Of course I can also do the reverse: find what key a command is bound to; in fact I can search my bindings as I type using helm-descbinds. I can search emacs documentation easily with the `apropos` command and its variants. Oftentimes in vim I generally only looked things up only after I already knew _what_ to look up, whereas in emacs I can easily explore things on my own and figure things out.

Emacs has much better extensibility features in general. In vim sometimes I would find something a plugin did that I wanted to work differently, and I pretty much only had two options: 1) file PR and hope the author agrees with my changes or adds them in optionally or 2) fork the plugin. 2 was out of the question because I didn't want the maintenance burden of maintaining a fork, and 1 was too much trouble sometimes for simple modifications or were simply too opinionated to realistically be accepted by the author. So pragmatically I just treated plugins as set-in-stone. With emacs I have much more options at my disposal ranging from advising [ http://www.gnu.org/software/emacs/manual/html_node/elisp/Adv... ], hooks, and in the worst case just redefining symbols with emacs lisp.

I was and still am hopeful for Neovim, but it'll take ages for it to catch up to emacs in terms of robustness and ecosystem, let alone similar feature set of emacs (which is probably a non-goal of neovim anyways). It's just an entirely different 'environment' in the sense of features and packages available to you.

I wonder if in the future we could leverage neovim's API functionality to have completely true vim bindings/editing within emacs. That would be the absolute best case scenario that I could imagine.

That said, I definitely believe that the default emacs bindings are horrible. I at first wanted to try to go cold turkey, 100% emacs, but the editing in emacs is just horrible to someone like me familiar with the speed and precision of vim editing, so I gave in and used evil, which is amazing. That saying about emacs being "a great operating system, lacking only a decent editor" rings very true to my ears, and with evil I have both.

blaenk··on What's new in Magit 2.x
I read it and it helped me switched to emacs after using vim for 10 years. It's great, as it teaches you the emacs 'mindset' instead of just being a dry procedural manual.
blaenk··on Things Rust shipped without
Abstract Return Types.
blaenk··on Finding Closure in Rust
Not sure what you mean. I understand that the compiler figures out what to do. My point was that it might be useful to remove certain restrictions from empty-environment closures to allow them to be used in more contexts, such as wherever a regular `fn` could be used (like for FFI callbacks).
blaenk··on Finding Closure in Rust
Like huon said, this is already the case, so I don't see how it could be confusing. The compiler would infer all of that and complain if the constraints are not satisfied. A literal fn syntax would be pretty cool, but I have doubts it'd ever be accepted, which is why I figured closure syntax could be adapted to allow this use case.
blaenk··on Finding Closure in Rust
Yeah, I forgot about that last point, which was the original reason I got this idea.
blaenk··on Show HN: rust-rss – library for serializing the RSS web content format
Wow, just now I needed something like this for my rust package!
blaenk··on Finding Closure in Rust
I think it would be useful if the distinction did exist in Rust, so that for example, "closures that have an empty environment" were indeed referred to as lambdas, and lambdas had the guarantee of being Sync, Send, Copy, Clone, etc., since they're more or less just like regular `fn` items as far as I know. As it is, a closure that captures nothing doesn't satisfy those bounds AFAIK, so their use is more restrictive than it needs to be. Instead, you're forced to write an actual `fn` definition, depriving you of the practicality and conciseness of closure syntax.
blaenk··on A Rust Contributor Tries Their Hand at Go
We should really think about getting something like this in rust/rustfmt. Syntax-level replacements sound pretty awesome.
blaenk··on The Time Needed to Write “Effective Modern C++”
I actually finished this book today. It's a great resource on the various pitfalls and good practices that are present in C++11/C++14, and they are presented in a very readable format that really lends itself to referencing later on. I highly recommend it.
blaenk··on Announcing Rust 1.0 Beta
Agreed. They allow you to naturally create vectors with the bracket delimiter `vec![1, 2, 3]`, create spawn-like macros with the brace delimiter `spawn { code }`, and in the normal case just use parentheses `println!("testing")`
blaenk··on Ask HN: Who wants to be hired? (April 2015)
Location: Los Angeles, CA or Orange County, CA Remote: Yes Willing to relocate: Unlikely Technologies: Rust, Haskell, Clojure(Script), Om/React, C++11, Go, Swift/iOS, Scala/Play!, Ruby/Rails, Python/Flask, Machine Learning Resume: https://www.dropbox.com/s/ml6njfjnswexpnz/resume-pub.pdf Email: jorge.israel.p@gmail.com Site: http://www.blaenkdenum.com

I'm a generalist who doesn't get bogged down with dogmatic views on specific technologies. I strive to learn a diverse set of technologies in order to keep an open mind and blend the best ideas from each [0].

[0]: http://www.blaenkdenum.com/notes/

Recently I've been finishing up a parallel, modular, middleware-oriented static site generator infrastructure library for Rust [1]. I also wrote idiomatic Rust bindings for Hoedown [2] (a C library for processing markdown) for use with Diecast. I expect to move my heavily customized Hakyll setup [3] to Diecast.

[1]: https://github.com/blaenk/diecast [2]: https://github.com/blaenk/hoedown [3]: https://github.com/blaenk/blaenk.github.io

I've been very active in the Rust community, particularly the RFC process and helping out on IRC. I also contributed a very minor fix to rustc itself and proposed a concept now known as "bound-targeting coercions" which has garnered support from the core developers and may be implemented in a future release.

blaenk··on Ask HN: Who wants to be hired? (August 2014)
Location: Los Angeles or Orange County, CA

Remote: Yes

Willing to relocate: Possibly

Technologies: Haskell, Rust, Clojure(Script), Scala/Play!, Swift/iOS, Go, C++11, Python/Flask, Ruby/Rails, Machine Learning

Resume: https://www.dropbox.com/s/ml6njfjnswexpnz/resume-pub.pdf

Email: jorge.israel.p@gmail.com

Site: http://www.blaenkdenum.com

As a generalist I don't like to get bogged down with dogmatic views on specific technologies. Instead I strive to learn a very diverse set of technologies in order to keep an open mind and blend the best ideas from each [0].

[0]: http://www.blaenkdenum.com/notes/

Note: There was an issue the last time I did this with a very loose gmail filter constraint I had setup. Apologies to anyone who responded and received no response; it has been resolved.

blaenk··on Ask HN: Who wants to be hired?
Los Angeles or Orange, CA · Remote/Local · Full-Time

Skills: Haskell, Rust, Scala/Play, Go, Python/Flask, Clojure, C++11, Ruby/Rails, Angular.js, Machine Learning

I'm a generalist who doesn't get bogged down with dogmatic views on specific technologies. In fact, I'm constantly learning about new ones in order to keep an open mind and learn new ideas [0].

Resume: https://www.dropbox.com/s/ek7vs0cd0rfpp06/resume-pub.pdf

Contact: jorge.israel.p@gmail.com

Site: http://www.blaenkdenum.com

[0]: http://www.blaenkdenum.com/notes/

blaenk··on What I Wish I Knew When Learning Haskell
Yeah. That somewhat resembles monadic behavior. Passing a container (list in this case) of functions and applying each of those functions to a container (again a list in this case) of arguments sounds a lot like an applicative functor. All monads are applicative functors though. Doing something in between each call definitely is more monadic than applicative, since that's more or less what the bind (>>=) function can do.
blaenk··on Why you should use OpenGL and not DirectX
It does have tessellation support and a programmable pipeline.
blaenk··on Linux may have been causing USB disconnects
For what it's worth, I too have a Das Keyboard (Ultimate) and I don't experience this problem (Arch 64-bit).

Hopefully that helps narrow down your issue.

blaenk··on VLC for iOS Now Available (itunes link)
> it costs a one time $100 charge to become an Apple developer

Just a nitpick, $100 per year last I checked, hardly a 'one time charge.'

blaenk··on Conrad Barski's Haskell Tutorial
This confused me when I was learning Haskell as well. The way I understand it is that regex-base defines a base-line interface -- such as the context-aware =~ function -- that all of the other packages implement, which is why they're known as 'backends' (e.g. regex-tdfa, regex-pcre, etc.).

In newer versions of GHC (> 6.6), the backends re-export this interface so that you just need to import the backend. regex-tdfa is the backend that I've used myself, mainly because I saw it used in other packages (Hakyll).

http://www.haskell.org/haskellwiki/Regular_expressions#regex...

blaenk··on Docker Tutorials
Thanks, that cleared it up for me at least.
blaenk··on Encrypt your Google chats and make the NSA sad
Today was the first day of WWDC 2013 which announced iOS 7, Mac Pro, OS X Mavericks, and iTunes Radio. Strenuous traffic load is expected this time of year.
blaenk··on Google and Adobe team up to improve fonts on iOS and Linux
In my experience, this doesn't necessarily give the correct font. Some distros have font aliases in fontconfig. I've found that `fc-match` can easily find the true font being used for a given font name/pattern, e.g. fc-match monospace might give DejaVu Mono
blaenk··on Gnome cofounder: Desktop Linux is a Chernobyl of Fail
Miguel de Icaza is hardly "some dev" though. http://en.wikipedia.org/wiki/Miguel_de_Icaza

> Miguel de Icaza is a Mexican free software programmer, best known for starting the >>GNOME<< and Mono projects.

blaenk··on Why learning Haskell makes you a better programmer
> Actually, I kind of wish IO was split up a bit... I have been meaning to play with rolling some typeclasses (with an IO instance and a testing instance) that wrap up IO of various types, so I define my functions in terms of these and spot what kind of IO various functions might do - I'm not yet sure how much of a win it will be, but it seems like something to explore.

There's a section on this practice in Real World Haskell: http://book.realworldhaskell.org/read/programming-with-monad...

blaenk··on Ozone Widget Framework developed by the NSA
Check out their website as well (which is buried in the project's readme): http://owfgoss.org/
blaenk··on Native Steam under openSUSE, Gentoo, Fedora, Arch
I'm most likely misunderstanding you, but a debian package (though I think geared towards Ubuntu) was the first thing released, in fact a lot of those listed in this wiki page are built _from_ the debian package. http://repo.steampowered.com/steam/
blaenk··on Do you really want to be making this much money when you're 50?
Thanks for this. As a first generation US citizen, there are times when I feel like maybe I fell short and should've aimed "higher", because I consider how easily programming comes to me that I figure it's easy for anyone, child's play compared to "hard" engineering and science like Physics, Electrical Engineering, or medical studies, law, etc. But it's true, like you said: the simple fact is that I love programming, so I figure that I'm fortunate enough to have found something I love doing so much, and will also (hopefully) allow me to live comfortably while doing it.
← PreviousPage 2 of 3Next →