www.ioremap.net

The inaugural get-together of the burgeoning NoSQL community crammed 150 attendees into a meeting room at CBS Interactive.

Like the Patriots, who rebelled against Britain's heavy taxes, NoSQLers came to share how they had overthrown the tyranny of slow, expensive relational databases in favor of more efficient and cheaper ways of managing data.

New data storages getting more and more attention especially from new projects which manage huge amounts of data. Conventional projects still use SQL and RDBMS though, and while it requires fair amount of overhead, it does not force rethinking and redesigning of the common data storage approach, since it is rather simple to work with.

But things are changing.

Article is available on ComputerWorld.

There is a new file distributed file system in the staging area of the 2.6.30 kernel called POHMELFS. Sporting better performance than classic NFS, it’s definitely worth a look.
...
Evgeniy Polyakov, a long time Linux hacker, has recently contributed a new distributed file system, called POHMELFS (Parallel Optimized Host Message Exchange Layered File System). It has appeared in the “chock-full-of-filesystems” kernel version 2.6.30 in the staging area. It is ready for testing and can give you a boost in performance (remember - it’s parallel!). This article will discuss POHMELFS and where it is headed.

An interesting article about POHMELFS, its state and future, namely elliptics network integration (with details on how it works and what to expect), NFS and its limitations.

Many thanks to Jon Smirl for the link.

I did not blog about technical stuff for a while since read some articles and books here and there about related topics. To date I did not get enough ground to start development, but there is already a short todo list to be completed in a week or so (well, only first couple of tasks are supposed to be finished, I will see later how it will go, it is unfeasible to finish them all quickly).

So, how knowledge extraction and cognition development processes are about to be implemented with time:

• Regexp parser implemented as a (non)deterministic finite automata. This task is not about to implement another bicycle, but to get in touch with complex state machines and their automatic generation from some abstract data and its relations.
• Test regexp implementation with html parsing and tag stack implementation. Can be used as a yet another HTML validator and sanitizer. Not that it is a particular goal, but to date I did not see any such tool with the extensible configuration (like with a tag substitution language) of how tag stack should be fixed upon error detection.

Above tasks actually form a minimum program (for the week or so). It is kind of HTML compiler. In particular, knowledge extraction task needs to have a regexp parser to select fact words (and combinations) and their relations if expressed not in a grammatically correct form (like changed prefixes and/or suffixes, i.e. 'plane flew over' -> 'plane' - 'fly' - 'over').

• Context-free grammatics. LR(1) grammatics. The latter is mainly to get in touch with the area. The former is a very powerful tool for the structured data analysis and its correctness.
• Knowledge extraction itself - building of the weighted graph of the word relations in the studied information.
• Input information processing:
  • Knowledge graph of the input data build based not only input text relations but also affected by the knowledge stored in the already processed data.
  • Question processing - generate a reply based on the existing knowledge.
  • Free actions - generate uncondition 'ideas' based on random spikes of action in the specified areas of the knowledge graph. Uncondition means not absolutely random, but random in the area with the highest knowledge weight concentration or in the area specified in the latest input data.
  • Input data analysis looking for known and unknown facts confirmation and extraction. Generating replies/questions based on those data.
• Linguistically correct reply generation using predefined grammatics.

To date I'm somewhere at the very beginning. Back to drawing board reading room...

I have a good contact with at least 3 musicians who finished musical schools and college in the past, and at least one of them still plays (in the neighbour room in the office).
They all saw my miserable and ugly attempts to play some notes and no fscking one (although I have to admit that I rarely rape ears'play' on public) said that scales exercises made from different notes in different keys are so extremely cool!

And they are - scales just rock! Not because they sound good, they are pretty usual and boring (although they also can be played with some fun), but after one somewhat memorized fingering of one or another scale playing its notes in the order you imagined in the head sounds just great.

Of course there are some additional notes which sound great in given rhythm and tonality, but even sounds from the simplest C major scale (C-dur iirc) form a nice melody. Spent an hour today morning playing various bits, and would continue further if not needed to move to the office.

And although I would not call it a good playing or somewhat interesting for more or less good musician, I liked it alot. Decided to make further lessons playing that way - memorizing scales in different keys and then improvise some bits 'there'.

Given that I have some troubles understanding time duration, it is rather hard to play very interesting albeit simple melodies. Actually not to play but to 'create' (in quotes since those simple melodies unlikely to require somewhat serious efforts from me, so I do not count it as a creation :). And although I try to play with the metronome, what I jam on my own is rather far from those sharp duration edges...

Ordered a set of mutes from UK (thanks to Meph who will bring it to Russia in a month or so, since no internet shop wants to ship it) - the more I learn the more I like and want to play. So decided to jam when I have a mood, and looks like office is a really good place for this.
Getting my playing skills it is better (and safer for myself) to play so that no one really hears that :)

Got Yamaha Silent Brass system (to play in office, yeah), cup mute to play at home when time does not permit and a harmon mute (eventually I will be a great jazz player, although maybe not in this life).
In late August this all will be here, but even without I want to continue. And to enjoy. And I do. Hope you too.

And partially 6b. That's what I climbed today, although without much success - it was rather hot and stifling, which does not favour high activity.

But nevertheless I tried couple of 6a traces (one of them on-sight, another one I tried on previous training), and both failed, but they were simple falls, so I even do not count them as real ones - I did not find a hold on the on-sight trace, so fell to check out around, and second traces with a fall was at the very end, so I was already tired.
But still they were not clean traces. Also climbed on the interesting 6a+ on-sight, and again fell to check how the trace went at the very end. Tried 6b, and it was not completed cleanly also - I was not able to complete the key, which I consider a major fall.

So, it was not something special, but not bad either, so I like how it goes.

Parallels band

Had a great fun yesterday at Parallels band concert. They celebrated one year of concerts and roughly 6 years after group creation.

Many things changed from those times, music improved, sky got darker, green made dirtier. But hard & heavy are still there. And was fucking cool!

More in gallery.

This is a major milestone in the elliptics network roadmap. System got full support of all essential operations needed for the fully self-contained distributed hash table storage creation.

Elliptics network is an object based distributed storage which supports different kinds of object replication, data deduplication, high-level file-based API and low-level object-based one. All logically complex parts are hidden behind provided API including failover connection processing, routing table maintenance, joining and synchronization protocols, merge strategies and IO itself.

Example applications contain a full-featured IO server and client capable of data replication and parallel reading and failover processing, system statistics gathering tool, notification receiver and history dump utility.

Elliptics server was built as a modular system which can have different storage IO backends, namely example server contains file IO storage (each transaction and history is stored in its own file, grouped into multiple directories), BerkeleyDB and Tokyo Cabinet database backends (each object and history are separate records in the appropriate databases).

This release brings us following features:

• advanced merge strategies
• local content sync (push into network) on node's join
• reference counted object removal
• automatic tests update (IO, joining, merge, deletion)
• bug fixes

This major release partially moves elliptics network into bug-fixing mode. Partially because all new features (like long-waited distributed PAXOS-based locking) are supposed to be added as external projects, i.e. either linked as libraries or implemented as daemons with the appropriate protocol extensions. This is not a strict limitation though, and major changes can be made in the library itself.

TODO list includes:

• POHMELFS port
• distributed locks for the replicated history updates (separate project)
• smtp/pop IO storage backend
• SSL support and IO authentification
• node/connection IO priorities

I will start working on this features after a short delay (about a week or two), whilst it will be settled down and checked by the interested parties.

As usual, you can check a homepage, archive and GIT tree.
Enjoy!

And now I'm switching into something very different (to have some rest and dig into relaxing of handwaving, thinking and designing) - knowledge extraction and automatic state machine building (for the regexp parser for example, but generally for the deeper understanding of the FSM generation process).
Stay tuned - I expect a lot of interesting results!

Climbing training was rather uncool - I did not finish any trace without falls.
Started with the quite complex beginning on the negative horizontal balcony - did not complete.
Moved to really complex 6c+ with the negative horizontal balcony and full of very passive holds - fell.
Then tried 6c over crack-in-the-rock holds - fell.
Tried new 6a (with the same balcony though) - again (although I think I will complete it next time without falls if started at the beginning of the training).

Started to make pull-up exercises on the holds (I selected rather deep ones and used big finger to help 2/3 of the time though) - succeeded. Although something tells me that when I started to pull up without full arm straightening (they are quite close to 180 degress in the elbow, but a bit less), it is not very fair. It looks like blood does not circulate well when arms are not yet fully unbend and it prevents them from quickly become clugeed up, so I'm able to make several pulls really quickly and without much efforts.

But anyway, even though the training was lazy and without excellent success stories, it was a good one.

In a meantime I implemented the last two features scheduled for the new release:

• synchronize local content when joining the node
• object removal support (yeah, elliptics network got it only now)

The former was rather trivial patch, but its consequences are vital for the correct distributed storage functioning. Now every joining node which has objects with IDs which fall out of the node's maintained range will be sent into the network and stored on the other sites. In particular this is useful for the cases, when network failure splits the whole network into parts. Previously joining node only copied data from other servers, but did not announce its own, which were outside of its ID range.

Object removal is a rather straightforward feature obviously needed for the system in general. But there are tricky places. Namely transaction support in the elliptics network implies that transaction with the same content will not be stored twice even if it was written into two or more different objects. Instead single object's history, corresponding to transaction content, will be updated to reflect that it is now shared by different objects.
Thus we can not simply erase transaction if it belongs to some objects to be deleted, instead we just drop a reference from the appropriate transaction history and only remove transaction when there are no external objects referencing it. This requires fair amount of testing, and another automatic test.
Also it is only implemented for the file IO storage backend now, and although it was made quite generic, BerkeleyDB and Tokyo Cabinet IO backends need to be updated.

Exported removal API contains two functions - high-level function to remove a file (the same way as read and write files from the local storage into/from the network), which blocks until completion and removes all file copies according to set of registered transformation functions; and low-level function to remove single object, which has a callback invoked when node acks transaction removal. The latter function will block waiting for acknowledge if no callback was specified.

Next task related to elliptics network will be a POHMELFS port. Then distributed locks.

But before that... Some shiny new ideas to think about in a very different area. And I expect it to be extremely interesting. Stay tuned!

Yamaha 8335 (G?)S Xeno (click to enlarge)

I played this one, 8310ZS and Bach Stradivarius 180ML43S. 8335 Xeno has a magnificent sound even with my rather limited technique. I did not think about air, lips or fingers - it just played.

Bach sounded the worst among tested models, but that's maybe because I was not able to play it (I tried standard Bach 7C and Yamaha 14C mouthpieces, my student mouthpiece is 7C), or because it was defective, which I heared is a very common problem.

Highpower@ liked light 8310Z sound more than Xeno though, but I prefered my feeling despite his professional opinion. I just love the sound Xeno produces.

It's damn perfect!

Having such instrument I must learn to play better than good, and eventually I will. As highpower@ says - 'let's listen you in two-three years'... Let's.

It is friday and climbing training again. This time it was rather simple one, I even managed to make a chin-up exercises at the end on the hold on the negative slope (as on campus-board).
But initially I climbed over couple of new traces and repeated 3 runs of one-after-anoter 6c trace (well, without its complex start on the negative horizontal slope, so its is a cheat). One of the new traces was something about 6a (maybe even 5c) on the vertical wall - and was finished on-sight.
Another trace is something really complex, like 7a, but again I skipped complex negative horizontal balcony and fell in the middle (but continued) and at the very end (where I still do not know how to move). I will try different negative horizontal starts as warming/beginning of the trainig - when I'm quite fresh and if exercise does not take a long time, I will quickly recover.

Expect a good progress since believe that I'm in a really good shape now.

Climbing is a freaking cool sport - everything strains, aches, relaxes and it just fires the roof!

Elliptics network is now able to work in a network split setup and system will merge different history logs when node rejoins.

There are 5 different strategies (described from joining node's point of view):

• DNET_MERGE_PREFER_NETWORK (0) - discard local changes and prefer version which exists in the network
• DNET_MERGE_PREFER_LOCAL (1) - send local transaction history into the network pretending it to be valid one, all changes in the history log, which is stored in the network will be discarded
• DNET_MERGE_REMOTE_PLUS_LOCAL_UPDATES(2) - apply all local changes made after the common ancestor commit after full remote log
• DNET_MERGE_LOCAL_PLUS_REMOTE_UPDATES (3) - apply all remote changes made after the common ancestor commit after full local log
• DNET_MERGE_FAIL (4) - fail if transaction logs do not match

The first two are obvious - we discard either remote or local history in favour of the selected version. All uptadates stored in the discarded log will be lost. The next two versions are also quite simple - we find a common ancestor and then apply the rest of the selected history log on top of the base one. In this case the first part of the merged log will contain either full remote or local history (depending on the selected strategy) and the second part will contain the rest of the other history.

Here is an example. That's how original history looks on both servers:

$ ./example/dnet_hparser -f /tmp/elliptics-test/root1/ff/ff00000000000000000000000000000000000000.history 
/tmp/elliptics-test/root1/ff/ff00000000000000000000000000000000000000.history: 
  objects: 5, range: 0-0, counting from the most recent (nanoseconds resolution).
2009-06-19 17:57:43.470096000: 32ea6116: flags: 00000000, offset:     2048, size:     2048: -
2009-06-19 17:57:40.814129000: af24ab16: flags: 00000000, offset:     8192, size:     4096: -
2009-06-19 17:57:40.656900000: 0054b454: flags: 00000000, offset:     4096, size:     4096: -
2009-06-19 17:57:40.503311000: 6cdd3cb9: flags: 00000000, offset:        0, size:     4096: -
2009-06-19 17:57:40.540129000: 6cdd3cb9: flags: 00000000, offset:        0, size:    12288: -
$ ./example/dnet_hparser -f /tmp/elliptics-test/root0/ff/ff00000000000000000000000000000000000000.history 
/tmp/elliptics-test/root0/ff/ff00000000000000000000000000000000000000.history: 
  objects: 5, range: 0-0, counting from the most recent (nanoseconds resolution).
2009-06-19 17:57:42.163033000: 51b89998: flags: 00000000, offset:     1024, size:     3072: -
2009-06-19 17:57:40.814129000: af24ab16: flags: 00000000, offset:     8192, size:     4096: -
2009-06-19 17:57:40.656900000: 0054b454: flags: 00000000, offset:     4096, size:     4096: -
2009-06-19 17:57:40.503311000: 6cdd3cb9: flags: 00000000, offset:        0, size:     4096: -
2009-06-19 17:57:40.540129000: 6cdd3cb9: flags: 00000000, offset:        0, size:    12288: -

Notice that coloured lines (also italic) are different and should be merged. That's how this will look after one of the merge strategies applied:

$ ./example/dnet_hparser -f /tmp/elliptics-test/root1/ff/ff00000000000000000000000000000000000000.history 
/tmp/elliptics-test/root1/ff/ff00000000000000000000000000000000000000.history:
  objects: 6, range: 0-0, counting from the most recent (nanoseconds resolution).
2009-06-19 17:57:43.470096000: 32ea6116: flags: 00000000, offset:     2048, size:     2048: -
2009-06-19 17:57:42.163033000: 51b89998: flags: 00000000, offset:     1024, size:     3072: -
2009-06-19 17:57:40.814129000: af24ab16: flags: 00000000, offset:     8192, size:     4096: -
2009-06-19 17:57:40.656900000: 0054b454: flags: 00000000, offset:     4096, size:     4096: -
2009-06-19 17:57:40.503311000: 6cdd3cb9: flags: 00000000, offset:        0, size:     4096: -
2009-06-19 17:57:40.540129000: 6cdd3cb9: flags: 00000000, offset:        0, size:    12288: -

or

$ ./example/dnet_hparser -f /tmp/elliptics-test/root1/ff/ff00000000000000000000000000000000000000.history 
/tmp/elliptics-test/root1/ff/ff00000000000000000000000000000000000000.history:
  objects: 6, range: 0-0, counting from the most recent (nanoseconds resolution).
2009-06-19 17:57:42.163033000: 51b89998: flags: 00000000, offset:     1024, size:     3072: -
2009-06-19 17:57:43.470096000: 32ea6116: flags: 00000000, offset:     2048, size:     2048: -
2009-06-19 17:57:40.814129000: af24ab16: flags: 00000000, offset:     8192, size:     4096: -
2009-06-19 17:57:40.656900000: 0054b454: flags: 00000000, offset:     4096, size:     4096: -
2009-06-19 17:57:40.503311000: 6cdd3cb9: flags: 00000000, offset:        0, size:     4096: -
2009-06-19 17:57:40.540129000: 6cdd3cb9: flags: 00000000, offset:        0, size:    12288: -

The same history will be placed both on local and remote nodes.

The last merge strategy - DNET_MERGE_FAIL (4) will fail with the following lines in the log:

2009-06-19 18:03:27.354246 2: ff000000: histories do not match and fail strategy was selected.
2009-06-19 18:03:27.354485 8: ff000000: failed to merge histories, err: -22.

Automatic test for this functionality (written in bash) is comparable in size with the feature itself.

There are only two issues left to implement in the elliptics network to be considered complete.
One of them is a known problem when joining node does not advertise objects it stores which are outside of the specified range, while it should merge them into the network. Although solution exists, it was not yet tested in this particular case - it is exactly the same as syncing failed range to the neighbour node.
Second problem is unlink support - objects have to maintain reference counter for the finer-grained deletion. Since transaction with the same content ends up in the same object thus performing automatic data deduplication, we can not simply delete it if it is referenced by two or more objects outside. Reference counting allows to remove object only when it is not referenced by any other object. Given that each low-level transaction (i.e. that one which contains some data and not a history update) has a history of the objects it is referenced from, deletion should not be a major problem.

After those tasks are finished I consider project as completed and it will be moved into bug fixing mode. To date I do not see any other features needed to be implemented in the core library (but I do remember about PAXOS-based locking for the backed up histories).

So plan to have a small rest after it and work on regext state machine implementation, LR grammatics and knowledge extraction. A small and rather simple AI bot should be developed for some mail lists this year, and I expect a lot of fun working with it.

In a week or so I will start porting POHMELFS to the elliptics network.

No, it is not cellular network generation, it the highest sound I was able to play. Today.
And even couple of harminic scales from 2F up to 3C/2G. Still usually can not play higher than 2F in the melody, but can run an upstairs scale now.
3G and other highest tones were produces by rounding bottom lip in and covered by the upper one. IIRC it is part of the Maggio technique, although I'm not really sure what school I play. It was fun to make that high tones, but I do not like the sound - it is rather empty, without interesting overtones. Main purpose for my level in playing in the third octave is to be able to play in the second octave very stable, which is not yet the case.

Added another exercises into the small set of various melodies and hear developing interval playing - playing with metronome (thanks to highpower@). I set it to 92 and play harmonic upstairs/downstairs scale for each 4'th tick in the first octave. I play either 4 same sounds with clear attack per tick and switch the tone after 4'th tick, or make the same tone for 4 ticks without interrupt and then switch it. Found that I can not play whole octave on a single breath, but that's mostly my wrong breathing, since I sometimes feel when air goes through the mouthpiece without producing a sound. Apparently lips are not very strong yet, but eventually I will develop this.

What's next interesting thing this day is about to bring?

I impressed myself today, which is a quite rare event these days. Today was a day of complex traces without physically hard places, i.e. effectively technique on the vertical wall.
And I'm good at it - I managed to complete vertical part of the 6c trace on-sight, and then make it (with couple of falls though) two runs of 3 traces without the rest in the set. While it sucked the power I managed to recover and move over the holds without that much of efforts. But have to admit that start of the trace (on the negative horizontal slope and then physically complex move over the balcony) I did not try and will not easily complete for sure.

Another set of one-by-one traces was 7a, but I used holds from the different traces for the feet though. Two such traces without the rest at the end of the training was enough to complete the day.

Well, also some shiny new 5b trace and couple of traverses, but these do not count.

Every training, learning or exercise should end up with the positive event, albeit complex enough to match the whole process, to make it cool. And that was just bloody cool.

I've almost recovered from being a weekend mosquito dinner so returned back to the interesting problem in the elliptics network: merge conflict resolve.

In the existing systems with the global index (like git) this problem is rather simple - index is always different, so system can find a common parent transaction and merge subsequent updates. There may be conflicts of course, but those conflicts can not be resolved generally without human intervention.

In the elliptics network there is no global index, instead each object has own history, which only contained applied transaction IDs, so it was possible that log will contain the same entries (like when updating the same block with the same data multiple times). Because of performance reasons each update does not end up generating a checksum of the whole object (which is not the case for git, where files are on the local machine and should not be fetched from the bunch of remote nodes, when some of them may be unaccessible). Since elliptics network does not have a global index with the always unique entries it is not possible to find a common parent for the two logs or this can be done with errors.

For example we can find two possible merge solutions for the diagram below:

1 2 3 4 5 1 2 3
          1 2 3 4 5
and
1 2 3 4 5 1 2 3
1 2 3 4 5
-----------------------------------> t

Where horizontal axis is a time and numbers are transaction IDs. To solve this merge conflict we need to know exactly how to differentiate transactions when their IDs are the same, and thus to find which path to take on the above diagram.
To solve this problem, I introduced a transction timestamp, which says when given data was sent into the network. It does not require a precise clocks on all machines in the network, since timestamp is only needed to be a unique number in pair with the given transaction ID, system does not use it to merge transactions based on its generation time.

I selected time since it is quite monotonically increasing number, while it could be a random cookie. Another useful usage of the timestamp is log truncation. Well, truncation is not a good definition though, since we cut off the log from the beginning dropping some old transactions. This is not implemented yet, while 5 different merge algorithms are:

• prefer network log and drop all local changes in favor of the version stored on the remote node
• prefer local log and overwrite the one stored in the network discarding all changes there
• apply local changes after common ancestor on top of remote log
• apply remote changes after common ancestor on top of local log
• do nothing and return error when remote and local transaction logs do not match

The first two are rather simple cases, while the third and the fourth (although being quite the same) are a bit more complex. They can destroy data consistency since transactions are applied on top of existing local or remote logs potentially overwriting data written there by another client. Although it is always possible to recreate object some time in its past, the latest version may be changed the way users do not expect.
Since it is potentially not a text file, usuall offset/size check (like in diff) is not enough (consider some binary tree updates). So there is the last case when nothing is done and it is up to administrator to decide which version is correct.

There should be a fair amount of testing of this functionality before new release will see the light, as well as other tasty features implemented, but core functionality is already there.

- How was that playing?
- Hmm, a... Kind of 16 bits

Nothing particulary cool, but I'm just warming :)
Will try again in a few moments, when people start going home.

EDITED TO ADD another couple citations:

- You do not have a sound

- If I would drink, I'd stop it

The latter was said when a passing pedestrian in the office heard how we played 'Hava Nagila' by trumpet and bass guitar. highpower@ and me were not in the best shape though...

Well, I kind of agree - when I'm drunk and there is an audience (even of one person) I can not play my best sounds, so, yes, it sucked. There were no attack and clear note's sound changes, lips did not always stay the right way and produced the sound I can play best, so instead it was most of the time some ugly crap.

But, but, but: I knew that myself (I always knew that I can not yet play when I'm drunk), so I suppose that my judgement about sound quality in the different condition is also correct and I do produce interesting sounds some other time.

But what I definitely have problems with is the sound duration and clear sound attack - I'm just bloody miserable at it, so even do not use it on the sheets and instead hear a melody played by the author to understand what and how it should be done. So I will buy a metronome tomorrow and will start playing and memorizing sounds with clear durations. And maybe will by a trumpet. Just to get myself a toy present: 6335(S), 8310(S)Z or even 8335 Xeno, although I incline to the light and sharp lead sound, so likely Z-series, but I will try to play it and hear how does it sound. Or maybe not, we'll see.

I'm not a good musician, but I like how things go, and I will improve.

2.6.30 is out and contains both POHMELFS and DST in staging directory.

While DST is a rather mature project and I do not expect it to change, POHMELFS will evolve into quite different entity.
To date it is a simple NFS-like filesystem with several features, namely the most interesting are local data and metadata writeback cache, ability to write to multiple servers and balance reading among them (you can find others on the homepage). This is really not a distributed filesystem, albeit a parallel one to some degree.

And reality says that no one really wants to change their existing NFS network to something new, even with higher performance, since the old systems already work and all their underwater stones were found.

Instead POHMELFS will evolve into the real distributed area with elliptics network, which will become its distributed hash table data storage. This is the main reason I will not ask to move POHMELFS from the staging tree for some time (at least in upcoming merge window) and will change it there.

Amount of features elliptics network provides is not really comparable with the existing old-school distributed systems, this is just a completely new and very different solution.

There is a number of potentially complex parts, but they are all solvable, so stay tuned for the new results!

EDITED TO ADD: Someone created a wikipedia article with spartan description :)

A good training - I tried 6c trace on the vertical wall over holds which are made as a crack in the rock first half of the trace. I finished it without problems, but second half is separated by the hard place which I was only able to move over (and finish the trace without falls) only when the first part was missed and I climbed there over simple holds.

I have enough technique for all holds and movements themself, but it is not in a very good shape yet, since I can not combine both parts together. Power endurance suffers also, but I suppose it is related.
Given that it is on the vertical wall with slight negative slope, since crack-holds themself are placed with a slope, so feet are always located left to the center of the mass, thus body heavily relies on the arms to hold it, I think I will complete it without falls rather quickly.
On the previous training for example I was not able to complete the first part cleanly.

At the end I started to pull oneself up on the board with passive holds. So far I use rather big ones, but getting I'm usually very tired when starting the ending exercises, it should not be a problem. I will move to the smaller holds eventually as well as run more starts.

So far I'm rather miserable there, but I'm just warming yet :)

Today I managed to play (piano tune) small C and 3C, the latter in a downstairs scale to 2F or so. I was able to play it multiple times although never in upstairs scale, and frankly I do not like the sound very much.

In the middle register sound is frequently (frequently now, but not always, and it was 'rarely' couple of months ago) interesting (imho of course), full of overtones and kind of ringing, while higher register sounds just like a plain tune. But I will extend it further.

Listened quite a few melodies played by professional trumpeters and found that most of them (besides loving the highest register) frequently play staccato (did I get it right that it is a set of short sounds very quickly following one after another). I can not do it that way, only sometimes my attepmts sound good, but usually it is a bit slower than needed. I still do not know how to use tune durations written on the sheet, so I play like I would like it to sound, which may be not right though.
Found that professional records are very rich even on the highest registers, which is definitely not the case for my playing (besides the fact that I rarely able to play there at all).

Another issue I discovered is small octave sound. Sometimes it just bloody good IMO, but again it happens rarely, most of the time it is kind of damped, there are no fresh, ringing overtones.

Decided to force myself to do the regular trumpet, piano, painting and reading 'trainings', the former several times a week at the morning, all the latters at the late evening when I return from the office (usually an hour or so for one of the tasks after 12).
If stars will draw up into the straight line I will play with a trumpet teacher, but I'm not 100% sure it will happen though.

Sometimes I think about getting a new trumpet, a bit more serious lead instrument (like Yamaha 4xxx or even Bach 37 or 43, I think I can afford another toy for myself :), although I like my $150 J. Michael 300S one.
I do want to hear how others sound in a real life and not in edited records though.

But no matter what, I see the progress and result, even on my own, which is a great pushing force to continue the process. Stay tuned, maybe eventually you will hear something interesting!

Patrick McHardy included OSF into netfilter tree.

OSF allows to passively detect remote OS and perform various netfilter actions based on that knowledge. This module compares some data (WS, MSS, options and it's order, ttl, df and others) from packets with SYN bit set with dynamically loaded OS fingerprints.

OSF was my first big kernel project, it is more than 6 years old already. During this time it was seriously improved by moving to RCU, extending configuration and parsing, and of course by fixing fair number of bugs.

It is not possible to print packet info into dmesg anymore, but instead it is possible to push packet into userspace and process it there via netfilter netlink log facilities. You will need to download the latest OSF release to get fingerprint loading application. Eventually I will extend it with some application to log packets in userspace, in a meantime one can use existing loggers.

Enjoy!

It was not somehow special training, I would even say a lazy one. I managed to complete the start of the mentioned 6b on the negative slope balcony, and even almost finished the whole trace after that. Also tried number of other 6a+/6b traces on the vertical wall and some gym exercises for the back.

Old problem still persists - I become tired very quickly so subsequent movements or new traces, if require at least some force, will be usually completed with falls. I will work on it with the exercises, but I do not expect power endurance to appear quickly.

So, to date, I have a quite strong technique level, I would say that I could complete 7a traces (I even did that on the vertical wall for couple of traces 2 years ago), but my power endurance is miserable, so I can not climb even 6a easily on the negative slope (I can usually do 6a on-sight on the vertical wall though, couple of times I managed to complete 6b traces on-sight, but that is rather an exception). But after some work on the trace I usually can move on 6a-6b on the negative slope, but it requires really lot of work to memorize the holds and body moves.

So, next milestone is scheduled to be a power endurance and static load improvement. I expect it to be achieved by special gym and climbing exercises, and would like if its rates are similar to what I got for muscle power improvements.

But we will see... I feel summer will be busy.

Today I believe I played my best sound - it was just what I always wanted to hear.
Trumpet sounds were so voiced, clear and had sharp attack, that I even thought I reached the edge I set for myself. As reached so pushed it further - it is quite stable, but not always and not always easy at small octave and higher than piano 2F. But that's what I know how to improve - practice. And I see some progress there.

But my hearing - I believe I do not really have it good. This weekend I spent with friends where among others tried to play both acoustic and electric guitar. I can not play guitar anymore (well, even 8 years ago it was something really miserable), so I just tried to pick out by ears some melodies I heared. It was noticebly different than that on trumpet or piano, but still it was very hard. I believe I succeeded on the part of the melody I tried, but it took maybe 10 or so minutes to pick out about 20 notes (I 'played' just on two strings).

Looks like my trumpet playing technique moves way too faster than hearing development, and practice I have does not help to develop a hearing. Need to do something with it.

Passive OS fingerprinting netfilter module allows to passively detect remote OS and perform various netfilter actions based on that knowledge. This module compares some data (WS, MSS, options and it's order, ttl, df and others) from packets with SYN bit set with dynamically loaded OS fingerprints.

This release brings following changes, some of which are not backward compatible and depend on upcoming 2.6.30 changes:

• switch from printk() to nf_log_packet() (2.6.30+ only, it depends on hook number provided through xt_match_param structure)
• comment and documentation update
• The latest MacOS X fingerprint (finally!)
• Split add/remove fingerprint processing callbacks and do not abuse internal netlink header fields
• WSS state machine cleanups (introduced enum instead of hardcoded char values, simplify checks)

Enjoy!

You know, sometimes even a tiny event can change everything. You hear an interesting sound, and mood goes well, you see someone or throw couple of phrases and day comes good. IIRC it is serotonin hormone's action.

Today I met a very interesting person on climbing zone I did not see for couple of years. We talked a bit about how things changed with time, and that was the final drop of the excellence - the day succeeded!

Although I did not make any serious progress on the climbing side - I tried technically complex 6c, but was only possible to complete it with lots of falls, then switched to the 6b with the start on the negative slope balcony, and miserably failed to complete its beginning part, but eventually managed to finish the rest part of the trace (on the vertical wall) 3 times without rest between runs. Not 100% clean though, but it is 3 times of 6b one-by-one after all, so I accept it as a good end of the training.

I actually can not understand what happens - I can run 3 times vertical-wall part of the 6b trace without the rest, but can not complete its start on the negative slope balcony even once. I'm pretty sure I could be able to complete 5 sets of forearm exercises with big and small weights (I started different ones though for my back and arms) after that, but was not able to run 5 holds on the balcony. Weird.
Will start campus-board and negative slope power endurance exercises from the next training - I want and will climb negative slope (event horizontal one) the same way I do the vertical walls.

Anyway, no matter what, it was an excellent day!

Elliptics network got a very minor release, which includes logarithmically increasing reconnection timeout (but not more than 30 seconds before reconnection attempt) instead of constant one and set of renames of the example binaries. Now all installled executable binaries (server, io testing utility, statistic gathering tool and notification example) are linked with dnet_ prefix, so if installed into common directory, they will not pollute the existing namespace (so stat utility will continue to work, since elliptics statistics gathering tool is not called dnet_stat). Also renamed example server with very loud non-trivial name example into dnet_ioserv.

Major work is being concentrated on the merge conflict resolving algorithm, which will fire up when joining node already contains objects which can be synced from the remote system. Merge problem rises when there was a network partitioning and object was updated from both parts of the net, or when node was placed temporarily offline and object it maintains was updated. This may require transaction history log format to be changed.

That's it, enjoy!

Thought of the weighted graph of the dictionary learned by the system, where node corresponds to the word, each link's value corresponds to the weight of the appropriate phrase, and amount of links going out of the every node determines how frequently given word was used in the learned texts.

The same graph can be built out of the new input sentence and already learnt data (like from memory), which will correspond to the meaning of the phrase by the given system. It is still quite rough in my head, but I have a thinking direction.

What I'm a bit stuck with yet, is a response generation. Let's suppose I determined from the question sentence its meaning. I expect it to be similar to what search engines output, but for example it should be quite different for questions like "where to swim on vacation in Moscow" or "do you like Stanislav Lem" and other similar kinds of questions.

Having a local system memory means subjective decision on each question, but I have troubles imagining how system should respond. How to program its own decision on what and how to answer when there is a (some kind of) understanding what was said.

Going to sleep, one says brain will think about the problem in the short sleeping stage, maybe I will be enlighted. I think its time to create AI tag for this kind of ideas :)
And it absolutely does not mean I stopped my other projects!

[video]

Another approach to solve text recognition problem - applying gravitation law between pixels, so that letters which are similar could 'collide' quickly. As we can see from the video, it works, but the same dynamics happens for any other letter, and the matter of the matching is not clear.

In theory the letter whose 'nature' was not changed after gravitation transformation is the one we are interested in, but it is quite unclear how to define a letter. Computer reads it as set of pixels - brain definitely treats it differently. For example when kids learn how to write they draw lines and circles or arcs, but not single points.

So I do not think above idea is right. I believe the right solution should involve a set of rules on how to write a letter. And when new picture is submitted, it could be interpolated by those rules, and if there is a clear match (like more than 3 quarters of the interpolation points fit the letter), then we consider letter as recognized (of course including scaling of the original image and set of interpolation points).
Simply speaking, we need to check if given picture can be drawn using 4 lines each of which has an angle less than 90 degress against other (for letter M or W), or a circle and a line (for letter P or b) and so on.

Problem is how to split a letter into the simplest parts which brain does easily, but computer can not, since it does not operate with higher-level objects. Maybe approach of splitting interpolation 'letters' into simple parts (like lines and circles or arcs), which will fit parts of the recognized picture (according to smallest square rule for example), and then we will check if resulted placement of those parts still match the letter they described originally.

Thinking, thinking, thinking. No clean idea, and that's good!

It was a miserable and full of falls training. My first several starts on the negative slope ended up with extremely quickly tired forearms (I believe they started aching even during warming traverses), so effectively I did not finish any trace there clear. Tried several traces on the vertical wall and only couple of the very simplest ones were completed without falls. I did not succceed even rather old 6a on the plain vertical wall...

But then I moved to the gym, where, hell knows how, I managed to perform lots of forearms, shoulders and back exercises without too much of efforts. Apparently something is very different between climbing and my exercises, although the same muscles work on both cases.
I think wall climbing has a mostly static load, while exercises are much shorter and thus do not enter that stage, even after a lot of repeats. So while training the power endurance and force, it is noticebly more light than climbing, especially on the negative slope.

Nevertheless I enjoyed it, even without any noticeble result.

Collegues in the neighbour office formed (and play right now :) a small band consisting of piano, bass and drums. All electronics. Sometimes they play really interesting compositions formed out of nothing just after several jamming minutes. Even current melody sounds good although it contains just about 10 notes played by bass - it is what is the loudests, so likely composition is more complex (for example piano plays by accords, which sometimes show up too).

Couple of times I though to get my trumpet and start raping the melody play in tune from my office :) At least those sounds what I hear could be excellently mixed with the brass timbre.

But I believe its too early though, so a question - drop me a melody name (with a sheet link if possible) which sounds great played by trumpet. I listened quite a lot of old-school brass jazz and actually was not very impressed, but maybe I missed some brilliant.

Please share your favourite music, which sounds great by brass instrument, which one can play alone!

If I will succeed playing it, I promise to share the record :)