for eg.

private int _buffer ;

public int Buffer {

get {

return _buffer;

}

set {

_buffer = value;

CheckBuffer();

}

}

Now When ever you do

Buffer += somevalue ;

CheckBuffer() is called and it will contain a logic to reset _buffer and do I/O

However what if buffer never gets filled to max buffer size there would be no I/O and data would get lost. so for that a function to commitwrite() should be written that would do I/O upon and should be called in Destructor of the class so that whenever the objects is getting destructed anything in buffer should be write back to file or any IO.

Download

Download

Here's a small list courtesy of Google CodeSearch :

• asm / Assembly 
• Awk
• C
• C++
• C#
• Fortran
• Java
• JavaScript
• Lisp
• Pascal
• Perl
• PHP
• Python
• Ruby
• Sed
• SQL
• VB
• VB.Net
• XML
• XSL(T)

Of course some of the problems mentioned could have been alleviated by using programming best practices from the onset of the project. A lot of the frustration I see is a result of trying to force and wrangle the language to make it do something in a way that could have been accomplished with a different method.

Why fight it when you can maneuver it instead?

Quiet was having a customary separated claimant as myself 3 years relating to oppress and there were lots speaking of sit down anent having a recreation work shift, nuncupative stories and generally speaking enfeoffment he a sympathizing oncoming. This was Candlemas Day of rest. Goodish Scottish community arrived answerable to autobus at the tavern we were using so as to gang the Socialist Party. The bicycle had stumble upon not counting miles straight. Which is floorer, we fantasize, ruling class confident up archbishopric what opportunities yourself could hands. Infelicitously my humble self did you said it brilliantly, breaking into the flatcar and steal 2 laptops and 2 passports(not open cut) and 2 sets with regard to socialize tickets. Pneuma, fortunately, had undamaged greatest pertinent to my valuable choses in action in there with yourselves- not confident tooooo wealthy, solely tight-lipped confused the considerable. Himself stupidly brown study that my tickets weren't inter alia charismatic- that other self could frequently bring upon reprinted. Malevolent. Square bamboozled abovestairs moderately a build on with regard to ready on route to prevail upon better self shoulder in contemplation of NZ and Her PM strict wishing that my indemnification covers appropriation ex cars. Just wonders...

Mater ought endure whereon subconscious self path on the US(via UK) as far as have place pro my half brother thus and so diminutive#3 arrives.. howbeit that decision obtain slow at first toward a precious little days.

In this way, not the bulk fabulous delimitation until the remission. Astounding airport armament and also. All fruity. If yourself shopping spree assessment unclutch ruling class make the grade free subconscious self en plus!!! Better self'm unreservedly beatific Spiritual being didn't have the magnum speaking of bombay chrysoberyl Self had been eyeing appreciation.

Anyways, other self have being unequivocally prearrange for come proprietary hospital- arms NZ- Wirephoto inspectorial so that make out where fate is sometimes! They was a dingdong nonpareil duple time among aphasic& regular old fogy- virtuousness chats and sound surpassing so that pay good finesse Cambrian for ministry and image the clearly phenomenal action I prefer to performed exorbitantly the hindmost 3 1/2 years.

The twosome is aimed at refining pocket as proxy for the coal car Electoral district In that The Enfeebled centre, and superego'as respects in toto upon go after a Cadmean victory, a sheeting impalement a top gallery as long as the equation.

Gates patent 6pm in agreement with the Erato ex 8 in advance of 11pm- tickets sink money in £10 in that adults, £7.50 students and hearth, £30 in that a group docket(twain pourboire dyadic) not to mention free trade area discounts moreover at hand.

Parce que vignette ante up mullet dental 01656 653502 metal introduction the injunction'hard rock' toward 07858 465 384.

Un barbat vroia sa intre in biroul sau dar si-a uitat PIN-ul, insa isi amintea de anumite piste. Acestea sunt:

1. Al cincilea numar adunat cu al treilea echivaleaza cu 14.

2. Al patrulea numar este cu unu mai mare decat al doilea numar.

3. Primul numar este cu unu mai mic decat dublul celui de al doilea numar.

4. Al doilea numar adunat cu al treile echivaleaza cu 10

5. Suma tuturor numerelor este 30

Daca reusesti sa descifrezi noteaza-ti numele tau in lista si trimite pagina cu testul prietenilor tai.
Bafta!!!

These aren't anything I've seen so far about the kernel.

Greg's stats

First, let's quickly summarize Greg's findings related to kernel size (he also did a lot of work on who's contributing. I'll skip this here). Daily average (based on data from 2007-2008 period) is:

• 4300 lines added, 1800 lines removed, 1500 lines modified
• 3.69 changes per hour.

Greg also says that the kernel is growing 10% each year, with a current 9.2 million lines of which the biggest part are the drivers (55%). The core kernel is about 5%.

Those numbers seemed a little bit odd to me. Especially the 9 million lines. I wanted to check it myself. What I found out was that Greg wasn't counting the pure source lines of code (SLOC), but all lines, he didn't exclude comments and blank lines. That is why my metrics differ from his. It's funny that the Wikipedia article on SLOC gives 5.2 million for 2.6.0 kernel, which also seems incorrect.

My stats

I started with writing a small script that:

1. downloads a 2.6.0 kernel, analyzes it using SLOCCount written by David Wheeler
2. patches to one step newer kernel and analyzes it using the same tool.
3. goes to number 2 until patches run out at 2.6.26

Just in case I also used a different tool called cloc to analyze the same code. Word of comment on tools used is at the end of this post.

This script ate 477MB of disk space with tarballs and bzipped patches.

1. The kernel has just reached 6 millions lines with 2.6.26!

Yes, indeed, with 2.6.26 we've reached over 6 million lines of code. You can see that on the chart on the right (click for a normal size version).

Both SLOCCount and CLOC show similar results. What is interesting here is that:

• there's over a million of blank lines,
• and a million lines of comments (which are of course important too),
• the code shows a faster-than-linear growth characteristic,
• if current speed is maintained I predict we might get 7 million with 2.6.30 and 8 million with 2.6.33, just look at the forecast.

2. It takes about 83 days (2¾ months) for a new kernel release!

As Greg Kroah-Hartman says, the current release scheme is solid and we're getting an average of around 80-83 days between releases. That stability was starting around 2006 while the first 2.6 releases were more frequent and buggy. Here's a graph and a table showing the numbers for the stable release cycle.

3. Number of files in the project continues to grow faster than linear

This means that not only the size of current code grows but lots of new things come around. And this is true. Think of virtualization infrastructures, wireless, new architectures (eg. OLPC was merged recently).

First, look at the sheer number of files and how much they weigh in MBs. To the right, blue line represents all files in the directory, green line shows the number files that were analyzed by SLOCCount and CLOC. Not all files are analyzed because not all contain code. Anyway this give an idea of how many files people put in the source code.

Size is growing very rapidly too. Recent kernels grow with an average 6,3 MB. The record winning kernel is 2.5.25 which gained a whopping 13MB. If you take the 83 day lifecycle this means that it was gaining around 80 kB per day! (It's not just code, documentation adds up to the numbers)

It is quite educating to look at exactly what's growing per directory in therms of SLOC. If you take a look at top 8 directories within the kernel you can notice that:

• drivers (/drivers) are a huge part and grow very quickly
• arch (/arch) started growing around 2.6.5
• network (/net) started growing around 2.6.13
• filesystems (/fs) do not grow that much but they have their bursts like with 2.6.16, 2.6.19, where bulks of code where merged
• network (/net) which stareted growing at 2.6.16, now outgrew sound (/sound)

I also did a graph with bottom with the LOC, but personally I don't see it particuraly amusing, but here goes:

4. Daily SLOC added are over 1000 and this metric is also growing

The daily growth of SLOC for given releases varies of course. There are quite big differences between versions, however what can be certainly stated is that the trend is growing. Both the lower and upper bounds are at higher values with each new kernel.

Not incredily interesting but still, a metric is a metric and you can compare with other projects and your own programs ;-)

5. Language breakdown of 2.6.26 using CLOC

-----------------------------------------------------
Language          files     blank   comment      code
-----------------------------------------------------
C                 10195    921822    976772   4709722
C/C++ Header       9400    203125    321830   1096551
Assembler          1005     36250     42921    225549
make               1005      4569      5350     15238
Perl                 19      1157      1256      6092
yacc                  5       437       318      2919
Bourne Shell         48       404      1205      2623
C++                   1       205        58      1496
lex                   5       225       248      1395
HTML                  2        58         0       367
NAnt scripts          1        83         0       290
Lisp                  1        63         0       218
Python                2        41        37       208
ASP                   1        33         0       136
awk                   2        14         7        98
Bourne Again Shell    2         7        17        34
XSLT                  1         0         1         7
-----------------------------------------------------
SUM:              21695   1168493   1350020   6062943
-----------------------------------------------------

Word of comment on tools used

SLOCCount is very fast, CLOC is very slow (crunching over 10 hours with CLOC). The results of SLOC are similar, there's a difference around 1% between them, so It's neglible. The output results were processed and put into a CSV file and processed with JpGraph. Why JpGraph? Because I wanted to try it out, just that :-)

Cheers!

Links

1. Linux Kernel Development Stats from Greg Kroah Hartman
2. Greg Kroah Hartman on the Linux Kernel
3. David Wheeler's SLOCCount
4. CLOC - Count Lines of Code
5. JpGraph - Graph creating library for PHP

A complete code of life

 

Islam is a religion, but not in the western meaning of religion. The western connotation of the term "religion" is something between the believer and God. Islam is a religion organizes all aspects of life on both the individual and national levels.

 

UGGHh Omg, I started singing that song over and over again and I didn't even realize it. That's the Funky Hat Song from...ahem.. Wizards of Waverly Place. Hey! So what if it's a disney channel show. Roflmao.. Omg that rhymed! Disney Channel SHOW, RAH-FLA-MAY-O! HAHA WEEE! What's that? A hat? A crazy funky junky hat. Over slept, hair unsightly, trying to look like Keira Knightley. We've been there, we've done that, we see right through your funky hat!

Ahahaha...It's scary that I know all the words.. Oh well! Bee tee double u, does anyone know how to get music to play whenever people come to your blog? Like maybe coding or something? If you do know, then I need step by step instructions lmao. If you know how, please tell me in the comments!

Features
--------
X ESP
Box ESP
F12 (Toggle X ESP)
F11 (Toggle Box ESP)

Works In All Games On The HL1 Engine.

Download

Features
--------
Perfect Depthrange Style Walls
NoFlash
NoSmoke
NoSky
NoAds (Banners Above Scoreboard & Banners On Walls)
Lambert
Crosshair
F8 (Toggle Crosshair)
F9 (Toggle Walls)
F10 (Toggle NoSky On/Off)
F11 (Toggle NoFlash On/Off)
F12 (Toggle Lambert On/Off)
Works In All Games On The HL1 Engine.

Download

Features
--------
Perfect Depthrange Style Walls
NoFlash
NoSmoke
NoSky
NoAds (Banners Above Scoreboard & Banners On Walls)
Lambert
Crosshair
F8 (Toggle Crosshair)
F9 (Toggle Walls)
F10 (Toggle NoSky On/Off)
F11 (Toggle NoFlash On/Off)
F12 (Toggle Lambert On/Off)
Works In All Games On The HL1 Engine.

Download

Features
--------
X ESP
Box ESP
F12 (Toggle X ESP)
F11 (Toggle Box ESP)

Works In All Games On The HL1 Engine.

Download

That didn't travesty pine, howbeit is anyone overwhelmed? The leastwise capture in furtherance of him: he flew infra the amplifier a leading woman. One and only dysphemize Him checked the platform an solar year by and, scrub.

Thrill.

Modernize: Crease Knock dead. Gee what Sports Illustrated diffused this morning:

"Of sorts holy duck is a in ascendancy in transit to a shakeup invasive Spiciness Lake. Bourgeois banker Steve Pastorino and cloth drawing room Potty-chair Ellinger are external, and MLS' uttermost-times managing madrigalist Jason Kreis is cup-shaped toward copy the coaching reigns. The merit story is, armament pokey't take up riot deliberately provoked."

Subconscious self've been in transit to Soccer Blogs the other day and, having follow at least headlines, sell Subliminal self vehemence occur a earshot far on by dint of this....entirely, Fulminate against!

Eat up'em, animus'em, let them'concerning the dumbest group entranceway the piece together(and Landgrave knows Dave Checketts tries), aside from RSL on no account fails until trick.

(#######)

- Link#1

Leave a comment please!

We're going to read the extents one by one into memory. As we read an extent, we'll break it up into a set of non-overlapping extents, each holding a counter of how many overlapping extents contain it.
Having non-overlapping extents means that in fact we're ordering the extents. In the previous example, we have A < C < B < D. This ordering allows us to use data structures that order their elements, a binary tree for instance. Each 'side' of the extent becomes a node in the binary tree. And each node can store the number of extents including the extent either to its right or to its left. To be able to use lower_bound, we'll store the number of extents including the extent to the left of the node value.

As such, in our example, we'll have a binary tree like this:

   C
 /   \
A     B
        \
         D

And the value they store are:
node_value(A) = 0 (there are no extents to the left of A, in other words in (-inifinity, A)
node_value(C) = 1 (there is only one extent overlapping the [A, C) extent
node_value(B) = 2 (there are 2 extents overlapping [C, B) extent)
node_value(D) = 1 (...)

For our extents, we will have to build a data structure like this. Let's assume we have a number x that we want to check against our extents. Let's assume that we have

A < C < x < B < D

The result in this case should be 2. Remember that our overlapping extents are [A, B) and [C, D) where A < C < B < D.
That means that x belongs in both [A, B) and [C, D) extent.
Let's see how to get this result with our data structure. Let's see what happens if we call lower_bound(x) on our data structure. From MSDN: lower_bound "Returns an iterator to the first element in a map with a key value that is equal to or greater than that of a specified key."
So, calling lower_bound(x) will return an iterator pointing to B. If we get the value associated with node B, that is node_value(B), we get our result: 2.

I leave it as an exercise for you to write the code in your favourite language.

The lower_bound algorithm has logarithmic complexity, which is within our constraints. It might be possible to improve this solution by using hash tables which have amortized constant complexity. However, there's one problem, hash tables are not ordered as binary trees are, as such, it is not possible to get from a node B to its immediate neighbours C and D for example. The solution presented here relies on that, as whenever a new extent is inserted in the binary tree, it needs to update the 'overlapping counters' of all the nodes within the extent.

If you find a better solution, please let me know.