HNHacker News
TopNewBestAskShowJobs

chaotic-good

182 karma · joined August 12, 2013

submissionscomments
chaotic-good··on iSAX 2.0: Indexing and Mining One Billion Time Series [pdf]
iSAX was an improvement over simple SAX indexing scheme that was known since 2005 or so.
chaotic-good··on Go GC: Solving the Latency Problem in Go 1.5
In erlang old data structures can't reference new data. This simplifies GC a lot.
chaotic-good··on InfluxDB Clustering Design – Neither CP or AP
Can I read about this storage engine somewhere?
chaotic-good··on InfluxDB Clustering Design – Neither CP or AP
What is throughput of the system per node?
chaotic-good··on Let's Build a Modern Hadoop
This technique usually called 'kernel bypass'. http://highscalability.com/blog/2013/5/13/the-secret-to-10-m... and http://lukego.github.io/blog/2013/01/04/kernel-bypass-networ...
chaotic-good··on From Node.js to Go
It has interfaces to write generic code. It doesn't allow you to write your own generic data structures but it's not an issue because it has built-in dynamic arrays and dictionaries. You supposed to use built in data structures most of the time like with python or ruby.
chaotic-good··on Vivaldi – A new browser for our friends
UI looks really cool though a little bit alien on ubuntu.
chaotic-good··on Vivaldi – A new browser for our friends
It is possible to search using address bar and separate search bar, why not to join them?
chaotic-good··on Go 1.4 is released
> What is unsafe about using atomic reference counting?

Nothing at all. But sharing objects between threads is unsafe.

> Like having a VM implemented in C defeats the purpose of the VM for that language being safe.

You can prove that VM code is memory safe? Good for you.

> Sure you can - owned and borrowed pointers in Rust are represented as raw pointers at runtime. It's a safe abstraction. And if there turns out to be a bug in that interface, and they aren't really safe, then that will have to be fixed promptly - unlike in C/++, where one would be forced to say "Well, that's your fault for not being careful".

And in C++ we have value and move semantics. Nobody uses pointer arithmetic to implement arrays and strings anymore. std::unique_ptr is a standard way to implement the same semantics as borrowed pointers in rust. Array access can be range checked if you want. So being careful in C++ is easy today, can I say that C++ is safe? :)

chaotic-good··on Go 1.4 is released
> This is also false. If you get memory unsafety outside of an `unsafe` block, it is a by definition a bug in the compiler.

All `unsafe` memory access in Rust performed in separate address space? I'm asking because if it isn't - this can't be called `isolated`.

chaotic-good··on Go 1.4 is released
It is common to use ARC and unsafe shared memory access in Rust. This defeats the purpose of this complexity. You can't isolate unsafe memory access. You rather write only memory safe code or end up with fully unsafe codebase where some nasty things (buffer overruns or segfaults) are possible. If somebody needs memory safety - managed languages with GC is the only real option.
chaotic-good··on Go 1.4 is released
It's too complex, we're already have C++.
chaotic-good··on Proxygen, Facebook's C++ HTTP Framework
Offtopic: I have a problem using fbthrift and cpp2 server together. I'm find that there is two IDL to C++ compilers that I need to use - one old thrift compiler written in C++ and the new one written in python. Code generated by both this compilers is used in tests! Is there any tutorial or article with step by step instructions?
chaotic-good··on Show HN: Akumuli – time-series database
Faster sequential writes. No compaction step needed. Constant amount of disk space is used.
chaotic-good··on Show HN: Akumuli – time-series database
Yes, it will be equivalent to db table indexed by timestamp. All data will be scanned but 86400000 values can be scanned in 10 seconds or so. In future I'm planing to implement some indexing based on bloom filters to speedup this. Now it is write optimized storage.
chaotic-good··on Show HN: Akumuli – time-series database
It's not deployed into production yet. What figures do you interested in?
chaotic-good··on Show HN: Sail boat simulation – try to sail into the wind
The most important rule of sail trim is to avoid turbulence on either side, __especially__ the leeward side. Laminar flow on the leeward side means the sail is deflecting air on that side as well, generating a "pull" in addition to the "push" on the windward side.

This is the reason why sails usualy have short strips of canvas on the leeward side - to see if there some turbulence or not. Turbulence depends on sail convexity, it can be changed too, not only sail angle!

chaotic-good··on Rust means never having to close a socket
Good generational GC doesn't need to deallocate objects one by one, instead of that it can deallocate objects in bulk (if there is no finalizers). It can allocate memory faster because it doesn't need to use memory allocator to create every object, it just increment pointer that points to the beginning of the free space. It's true that modern GC has greater throughput than simple allocation/deallocation schemes. Problem is predictability (as been mentioned).
chaotic-good··on Rust means never having to close a socket
In Rust, unlike in garbage collected languages, you never1 explicitly close or release resources like files, sockets and locks

GC languages is trying to emulate machine with infinite memory so you don't need to bother yourself with _memory_ management. It's not compatible with rust's resource management system that manages resources and treats memory as another type of resource. The same is true for C++ BTW, in good C++ code you never release resources by hand and use ownership for this (RAII).

chaotic-good··on Lock-free Data Structures: Atomicity and Atomic Primitives
This is translation from Russian. Original article is here: http://habrahabr.ru/company/ifree/blog/195948/
chaotic-good··on Some thoughts on Go and Erlang
> Hmm. Given that you accused the author of making biased comparisons, I would expect some more detailed information there. "Faster" doing what? Assembly is faster, Go isn't. Ok, let's use assembly then.

This makes big difference. With pure Go I can do computation heavy things, for example - I've implement some information retrieval methods in Go (indexes, stemmers, ranking and so on). I can't do the same in Erlang, because my map based inverted index, written in Erlang will be to inefficient. I can write it in C, but in my case - most of the application complexity is located in this information retrieval part. Because of that, efficiency is a big deal for me.

chaotic-good··on Ask HN: What are you working on and why is it cool? (February 2014)
https://github.com/Lazin/Akumuli - embedded time-series database. I'm trying to achieve very high write throughput - about 1M updates per second. The key idea here is to store data in large sorted files and search them with interpolation search with fall-back to binary search in some cases. I expect this method to be much more efficient than b-tree or LSM-tree for time-series data.
chaotic-good··on Go for System Administrators
Since import statements do not allow you to specify versions, you have to keep track of which commits of a particular project you trust. I am pretty sure that this problem will be solved, but it currently isn't.

Go forces everybody to use green master policy. Every library is expected to have green master and stable API. If you need to change API of your Go library, you must create new repository.

← PreviousPage 3 of 3