The purpose of copyrights is to advance science and useful arts, not to reward authors.
If rewarding authors for that purpose is required, then they will be rewarded.
Copyrights on binaries however, reward authors while stifling the progress of science and useful arts.
It encourages people to create secretly-operating software that helps them get revenue but does not inspire new works, does not enter the public domain and does not help anyone else in the long run.
It is rediculous that binaries are copyrightable and the law that allows it is actually quite new (from the late 70's) and should be reverted.
I find it appauling that people actually buy it that reverse engineering here is immoral.
Other then the idea that the universe magically created itself and everything in it, exactly what parts of '200 years and thousands of independant(sic) pieces of information and the entire biology branch of science' have to be ignored? Creation is no more far fetched then evolution, your just changing what your god is.
Who said the universe was "created"? Time is part of the universe, so there is no meaning to the phrase "before" the universe. Creation implies that there is a time "before" the universe, so it could not have been created (Unless time is not part of the universe, but then you can define the "universe" to be a larger thing that does include time). Also, the observable law of conservation of mass and energy suggests that there was no point in time with a different amount of mass/energy thus strongly suggesting there was never a "creation".
The theory of relativity also suggests that time may be finite and there may be a point with no points in time before it, allowing the universe to never have been created and finite.
Also, changing my "god" to be "evolution" and the laws of physics is a big change. Because I am not only changing who my god is, I am changing the amount of complexity I throw unto this creature "god" which obviously represents the never-to-be-known. Thus I have more that I may know and less that I will never know.
Strictly speaking, "virtual memory" means the addresses seen by the running code are translated to physical addresses (by the MMU). Thus, the code sees virtual addresses.
"Memory protection" describes the feature where the running code is prevented from accessing certain parts of memory, for security/stability reasons. This is called "memory segmentation" on some architectures, which is where the Unix phrase "segmentation violation" (SIGSEGV, or "Segmentation fault) comes from.
Well I have always seen "virtual memory" as the feature implemented by page tables, but perhaps my terminology is not accurate and it only refers to one aspect/feature of the page tables. "segmentation", at least in Intel terms, means a segment of code or data and a set of protection/attributes. It can indeed be used to implement protection, but most modern OS's that run on Intel simply use 0..4GB segments to map the entire memory (code/data ring0, code/data ring3) and forget that they exist (for the most part).
Protection in modern OS's usually uses protection bits in the same page tables that are responsible for the translation of virtual addresses to physical addresses. I have not heard this called "segmentation" before, and it sure isn't in Intel terms, but perhaps it is in old Unix jargon. Surely it makes "Segmentation fault" make more sense as a result of page faults:-)
I know there are systems which implemented protection without virtualization, and I suppose it's possible (if silly) for the reverse to be true, too. So, while the two are closely related, and both are implemented by the hardware MMU (Memory Management Unit), they are not the same.
Again, it may be an inaccuracy on my part to include protection as a "virtual memory" feature. In any case, I am quite certain that demand-loading is indeed part of that feature in all common terminologies. However, a discussion that revolves around terminology will soon find me out of it:)
Note that the above kind of "segment" has nothing to do with the 8086's 64 KB segments. The 8086 supported a 1 MB address space, but a 16-bit address word was used for most things. I assume that was due to price/performance limitations imposed by the technology of the day, but I don't know.
Yeah, the 8086 had a silly (segment<<4 + offset) memory scheme, that allowed for just a bit more than 1MB mapping (64K-16 bytes to be exact:-) addressing via two 16 bit registers.
The 80286 did support memory protection, but not a flat memory model. You still had to worry about segments, although the segments could be larger. (I want to say 16 MB, but that might have been the total address space -- it's been awhile.) I don't remember if the 80286 supported virtualization.
The segments had a 24 bit base and a 16-bit limit, so the segments were limited to 64K in size (as the 286 offsets were limited to 16 bits it made no sense to allow larger segments) but could be mapped to anywhere within the 16MB of memory space.
"Swapping" means taking an entire process's memory space and writing it out to disk. This came first, because it can be implemented without an MMU.
More importantly it was possible with 286's architecture. Not sure it actually came first on *nix architectures though.
"Paging" means taking chunks of memory not recently used and writing them to disk. So-called because virtual memory manages memory in chunks called "pages". This needs an MMU, because the process keeps running even with big chunks missing. When a process tries to access a page that is out-of-core, it causes the MMU to issue a page fault, which the OS traps. The OS then brings the page in from disk and resumes the process.
Virtual memory is indeed the virtual tables that allow for virtual memory -> physical memory mappings that can differ for isolation purposes.
However, those same virtual tables are used to mark pages as not-present to indicate they are stored on some external storage or do not exist at all. This is also known as a "Virtual memory" feature, so it is not inaccurate to say one of the purposes of virtual memory is to virtualize more memory than is physically available.
Also, the 80286 already added the protection features required to prevent applications from crashing the system and each other, but those features are very complicated and although still supported, they are mostly unused by most modern operating systems.
P.S Some of those features could actually be of benefit (for example, using segmentation to have the stack mapped only in the data selectors and not mappable in the code selector could prevent most b.o exploits)
The solution they came up with was to use some space on the hard disk as extra RAM. Although the hard disk is much slower than RAM, it is also much cheaper and users always have a lot more hard disk space than RAM. So, Windows was designed to create this pseudo-RAM or in Microsoft's terms - Virtual Memory, to make up for the shortfall in RAM when running memory-intensive programs.
Amazing how they manage to turn everything around as though Microsoft invented the world of computing...
Virtual memory, the term and the implementation have been around long before Microsoft came into existence.
Some of us simply do not believe copyright law is just, and think that it is draconian and absurd.
Obeying laws, even absurd ones, is generally good, in order to avoid contempt for the law. Unfortunately, in the case of copyright, obeying the law means empowering the lobbyists that keep the law alive and strengthen it.
The best way is to avoid copyrighted works, and when they are not avoided, at least do not pay those who push for the continuation of the copyright regime.
Piracy is name-calling, and the reason copyright infringement is so common is because people do not find the copyright deal reasonable anymore, ever since the digital revolution.
To make laws that man cannot, and will not obey, serves to bring all laws into contempt. -- Elizabeth Cady Stanton
Unfortunately, due to this law and others, law is already in contempt by the vast majority of the public...
GPL is just another way of restricting what others can do, which makes the hypocrisy harder to defend
The GPL indeed restricts what you can do, but it does not restrict freedom, it only restricts power.
It is important to differentiate between a freedom and a power. To be able to distribute a work while restricting other's freedoms is a power, not a freedom.
This is why the GPL is indeed more free: it increases the net freedom of all software at the expense of users' power.
A. This must be legal, or all receivers of content on the web are infringing on copyright law. B. This must be legal, because in order to download data from the site, no legal agreement must be signed and there is no legal obligation to not modify the content. C. This should be just as legal as a router's redistribution of the content of the site to the other routers, and nobody sane even considers applying copyright law to automatic redistribution of content for technical reasons. This should also be legal because again, there is no legal obligation on the side of the receiver to not redistribute the content.
C++ memory management has a form of "GC" which is usually done via reference counting, auto_ptr's, etc.
If this is not used, and memory is completely manualy managed for performance reasons, it is no longer "good C++". With today's algorithms, requires O(n) to allocate (n being a function of the available memory count or hole count, depends on the scheme) and O(n) or O(1) to free (in the case of O(1), allocation is typically inefficient.
With good generational GC, you can get O(1) allocation, O(1)-amortized freeing (O(n) memory restructuring once "every n free calls"). The downsides are an extra dereference on every ptr, but this can be overcome with smart paging tricks and/or "safe" zones where GC won't be called (the dereference only has to occur once in those).
In theory, there is no reason for explicit memory management to be slower than any form of GC, but in practice (of existing methods), manual memory management is actually of far worse performance than good GC. Unfortunatly, this is also true of GC, which is also implemented in a very unideal way.
Anyhow, in conventional C++, every ptr assignment requires increasing/decreasing a refcount, which is more expensive than periodic mark and sweep under some scenarios of cache locality.
Its way too complex to compare GC to non-GC in theory as they are affected by too many factors. All existing implementations of both GC and malloc/free are highly inefficient, so benchmarks are also moot.
Maybe in 20 years we'll reach a concrete conclusion on that one;)
Honestly, I can't tell you how often I've had two or three windows open, needing info from all three but not neccessarily from the whole window of each.
Notice what I said : "with the user and application cooperating to define which parts in the visible output of the application are important to the user at every given moment so that those are automatically displayed to the user.".
My idea is that you will be able to somehow define what is important for you to see, not necessarily at the window level, but possibly at the widget level, such that the specific info from _those_ widgets is displayed.
Hell, maybe the hierarchy of widgets should become a new primitive instead of windows, allowing the window manager to reorganize that hierarchy to place items defined with similar importance together.
Managing their rotation axis and depth is more waste of time.
Windows should either be auto-maximized or auto-tiled by the windowing system, with the user and application cooperating to define which parts in the visible output of the application are important to the user at every given moment so that those are automatically displayed to the user. Simple example: Newly created messages about errors or events should not be placed on top of some text I am reading, but on some of the all-gray or all-white area that the screen almost always contains. For this to happen, it must know that text is more important than "dead" areas that contain nothing.
This silliness of attributing physical traits to non-physical entities is counter-productive, even if it is very visually appealing.
Lets let go of the overlapping windows crap and solve the division of screen-space problem in a more intelligent way.
Comments should be used LIBERALLY, albeit intelligently as well. If you do something that isn't intuitively obvious to even the most casual observer, just take 30 seconds to write a fucking COMMENT explaining why you did what you did.
I do not understand what you mean by the "most casual observer"... Typically, casual observers of code are coders, so most code can be written to be obvious to them. That means that comments should be used in the rare cases where it is not possible or very difficult.
Believe it or not, eschewing comments because "oh, well, if you want to understand it just read the code" just pisses those of us off who have to come along and clean up your miserable excuse for a codebase... and it sure as hell doesn't prove how studly a programmer you are.
No, programmers should avoid comments for clearer code not because it takes 20 seconds to write them, but because it takes a lot more time to update commented/redundant code and it usually leads to inconsistent and incorrect documentation as the code evolves.
Comments are a form of redundancy to the code as well as testing, static typing, etc. Redundancy has its advantages but it is mostly disadvantageous as it makes changes difficult and in the case it is not automatically checked for consistency (documentation) it usually leads to the lack thereof.
That doesn't mean half your codebase should be comments, but it does mean that you should at least make a passing nod to demystifying your own attempts at cleverness. I have lots of better things to do than to spend all fucking day picking apart your rabbit's nest of code before I can make a change, add a feature or fix a bug.
That's why code should not be clever, it should be simple and as obvious as possible.
People that honestly believe that "if it's well written it doesn't NEED comments" should be strangled with their mousecord and hung in their cubicles as a warning to the rest.
A lot of code can be written as to not require comments for proper understanding. The best documentation of what the code does is the code itself:
Its always up-to-date
Its always completely consistent with the behavior of the program
The EULA is not a legal contract, as no law requires you to agree to the vendor terms in order to use the legally purchased copyrighted works nor does any law give meaning to clicking "I agree" buttons on a computer screen.
Google mostly solves the organizational problem since it organizes the information you need from the entire web according to the criteria you need on demand, at the very moment you request that organization...
Filtering signal from noise is also helped by google, as they measure the amount of links to a site which increases the odds it is not noise. I rarely find blog entries as results for my searches.
Slashdot Mirror
The purpose of copyrights is to advance science and useful arts, not to reward authors.
If rewarding authors for that purpose is required, then they will be rewarded.
Copyrights on binaries however, reward authors while stifling the progress of science and useful arts.
It encourages people to create secretly-operating software that helps them get revenue but does not inspire new works, does not enter the public domain and does not help anyone else in the long run.
It is rediculous that binaries are copyrightable and the law that allows it is actually quite new (from the late 70's) and should be reverted.
I find it appauling that people actually buy it that reverse engineering here is immoral.
Other then the idea that the universe magically created itself and everything in it, exactly what parts of '200 years and thousands of independant(sic) pieces of information and the entire biology branch of science' have to be ignored? Creation is no more far fetched then evolution, your just changing what your god is.
Who said the universe was "created"? Time is part of the universe, so there is no meaning to the phrase "before" the universe. Creation implies that there is a time "before" the universe, so it could not have been created (Unless time is not part of the universe, but then you can define the "universe" to be a larger thing that does include time). Also, the observable law of conservation of mass and energy suggests that there was no point in time with a different amount of mass/energy thus strongly suggesting there was never a "creation".
The theory of relativity also suggests that time may be finite and there may be a point with no points in time before it, allowing the universe to never have been created and finite.
Also, changing my "god" to be "evolution" and the laws of physics is a big change. Because I am not only changing who my god is, I am changing the amount of complexity I throw unto this creature "god" which obviously represents the never-to-be-known. Thus I have more that I may know and less that I will never know.
Images formed upside down
Why does it matter where the photo-receptors are physically if they can be logically connected in any way?
According to E=mc**2, fuel energy is not scarce at all, its just difficult to use.
But to say that is due to IP is to pass subjective judgement.
Try to repeat this after IP is cancelled, see if the tech industry dies, or suddenly becomes innovative.
That PDF sucks. Use HTML.
My understanding:
:-)
:)
:-) addressing via two 16 bit registers.
Strictly speaking, "virtual memory" means the addresses seen by the running code are translated to physical addresses (by the MMU). Thus, the code sees virtual addresses.
"Memory protection" describes the feature where the running code is prevented from accessing certain parts of memory, for security/stability reasons. This is called "memory segmentation" on some architectures, which is where the Unix phrase "segmentation violation" (SIGSEGV, or "Segmentation fault) comes from.
Well I have always seen "virtual memory" as the feature implemented by page tables, but perhaps my terminology is not accurate and it only refers to one aspect/feature of the page tables.
"segmentation", at least in Intel terms, means a segment of code or data and a set of protection/attributes. It can indeed be used to implement protection, but most modern OS's that run on Intel simply use 0..4GB segments to map the entire memory (code/data ring0, code/data ring3) and forget that they exist (for the most part).
Protection in modern OS's usually uses protection bits in the same page tables that are responsible for the translation of virtual addresses to physical addresses. I have not heard this called "segmentation" before, and it sure isn't in Intel terms, but perhaps it is in old Unix jargon. Surely it makes "Segmentation fault" make more sense as a result of page faults
I know there are systems which implemented protection without virtualization, and I suppose it's possible (if silly) for the reverse to be true, too. So, while the two are closely related, and both are implemented by the hardware MMU (Memory Management Unit), they are not the same.
Again, it may be an inaccuracy on my part to include protection as a "virtual memory" feature. In any case, I am quite certain that demand-loading is indeed part of that feature in all common terminologies. However, a discussion that revolves around terminology will soon find me out of it
Note that the above kind of "segment" has nothing to do with the 8086's 64 KB segments. The 8086 supported a 1 MB address space, but a 16-bit address word was used for most things. I assume that was due to price/performance limitations imposed by the technology of the day, but I don't know.
Yeah, the 8086 had a silly (segment<<4 + offset) memory scheme, that allowed for just a bit more than 1MB mapping (64K-16 bytes to be exact
The 80286 did support memory protection, but not a flat memory model. You still had to worry about segments, although the segments could be larger. (I want to say 16 MB, but that might have been the total address space -- it's been awhile.) I don't remember if the 80286 supported virtualization.
The segments had a 24 bit base and a 16-bit limit, so the segments were limited to 64K in size (as the 286 offsets were limited to 16 bits it made no sense to allow larger segments) but could be mapped to anywhere within the 16MB of memory space.
"Swapping" means taking an entire process's memory space and writing it out to disk. This came first, because it can be implemented without an MMU.
More importantly it was possible with 286's architecture. Not sure it actually came first on *nix architectures though.
"Paging" means taking chunks of memory not recently used and writing them to disk. So-called because virtual memory manages memory in chunks called "pages". This needs an MMU, because the process keeps running even with big chunks missing. When a process tries to access a page that is out-of-core, it causes the MMU to issue a page fault, which the OS traps. The OS then brings the page in from disk and resumes the process.
This is accurate.
The 80286 added 16-bit protected mode, but paging (Virtual Memory mechanisms) was only added in the 80386.
Swapping was possible in the 80286 using the present bit of segments, but not paging.
Virtual memory is indeed the virtual tables that allow for virtual memory -> physical memory mappings that can differ for isolation purposes.
However, those same virtual tables are used to mark pages as not-present to indicate they are stored on some external storage or do not exist at all. This is also known as a "Virtual memory" feature, so it is not inaccurate to say one of the purposes of virtual memory is to virtualize more memory than is physically available.
Also, the 80286 already added the protection features required to prevent applications from crashing the system and each other, but those features are very complicated and although still supported, they are mostly unused by most modern operating systems.
P.S Some of those features could actually be of benefit (for example, using segmentation to have the stack mapped only in the data selectors and not mappable in the code selector could prevent most b.o exploits)
The solution they came up with was to use some space on the hard disk as extra RAM. Although the hard disk is much slower than RAM, it is also much cheaper and users always have a lot more hard disk space than RAM. So, Windows was designed to create this pseudo-RAM or in Microsoft's terms - Virtual Memory, to make up for the shortfall in RAM when running memory-intensive programs.
Amazing how they manage to turn everything around as though Microsoft invented the world of computing...
Virtual memory, the term and the implementation have been around long before Microsoft came into existence.
That's an oxymoron...
Some of us simply do not believe copyright law is just, and think that it is draconian and absurd.
Obeying laws, even absurd ones, is generally good, in order to avoid contempt for the law. Unfortunately, in the case of copyright, obeying the law means empowering the lobbyists that keep the law alive and strengthen it.
The best way is to avoid copyrighted works, and when they are not avoided, at least do not pay those who push for the continuation of the copyright regime.
Piracy is name-calling, and the reason copyright infringement is so common is because people do not find the copyright deal reasonable anymore, ever since the digital revolution.
To make laws that man cannot, and will not obey, serves to bring all laws into contempt. -- Elizabeth Cady Stanton
Unfortunately, due to this law and others, law is already in contempt by the vast majority of the public...
GPL is just another way of restricting what others can do, which makes the hypocrisy harder to defend
The GPL indeed restricts what you can do, but it does not restrict freedom, it only restricts power.
It is important to differentiate between a freedom and a power.
To be able to distribute a work while restricting other's freedoms is a power, not a freedom.
This is why the GPL is indeed more free: it increases the net freedom of all software at the expense of users' power.
An easy solution for you.
You choose.
Choose GNOME or KDE.
Choose a distribution, or use a configure script (--prefix solves all your filesystem dillemas).
Proceed to use only those choices and ignore the rest.
You have now reached a standardized desktop for yourself and a target platform to develop for, congratulations.
A. Asks content from sites and stores it
B. Modifies the content in trivial ways
C. Redistributes the content to any receiver
A. This must be legal, or all receivers of content on the web are infringing on copyright law.
B. This must be legal, because in order to download data from the site, no legal agreement must be signed and there is no legal obligation to not modify the content.
C. This should be just as legal as a router's redistribution of the content of the site to the other routers, and nobody sane even considers applying copyright law to automatic redistribution of content for technical reasons. This should also be legal because again, there is no legal obligation on the side of the receiver to not redistribute the content.
So which of A, B or C are illegal, and why?
C++ memory management has a form of "GC" which is usually done via reference counting, auto_ptr's, etc.
;)
If this is not used, and memory is completely manualy managed for performance reasons, it is no longer "good C++". With today's algorithms, requires O(n) to allocate (n being a function of the available memory count or hole count, depends on the scheme) and O(n) or O(1) to free (in the case of O(1), allocation is typically inefficient.
With good generational GC, you can get O(1) allocation, O(1)-amortized freeing (O(n) memory restructuring once "every n free calls"). The downsides are an extra dereference on every ptr, but this can be overcome with smart paging tricks and/or "safe" zones where GC won't be called (the dereference only has to occur once in those).
In theory, there is no reason for explicit memory management to be slower than any form of GC, but in practice (of existing methods), manual memory management is actually of far worse performance than good GC. Unfortunatly, this is also true of GC, which is also implemented in a very unideal way.
Anyhow, in conventional C++, every ptr assignment requires increasing/decreasing a refcount, which is more expensive than periodic mark and sweep under some scenarios of cache locality.
Its way too complex to compare GC to non-GC in theory as they are affected by too many factors. All existing implementations of both GC and malloc/free are highly inefficient, so benchmarks are also moot.
Maybe in 20 years we'll reach a concrete conclusion on that one
Honestly, I can't tell you how often I've had two or three windows open, needing info from all three but not neccessarily from the whole window of each.
Notice what I said : "with the user and application cooperating to define which parts in the visible output of the application are important to the user at every given moment so that those are automatically displayed to the user.".
My idea is that you will be able to somehow define what is important for you to see, not necessarily at the window level, but possibly at the widget level, such that the specific info from _those_ widgets is displayed.
Hell, maybe the hierarchy of widgets should become a new primitive instead of windows, allowing the window manager to reorganize that hierarchy to place items defined with similar importance together.
is counter-productive.
Managing their rotation axis and depth is more waste of time.
Windows should either be auto-maximized or auto-tiled by the windowing system, with the user and application cooperating to define which parts in the visible output of the application are important to the user at every given moment so that those are automatically displayed to the user. Simple example: Newly created messages about errors or events should not be placed on top of some text I am reading, but on some of the all-gray or all-white area that the screen almost always contains. For this to happen, it must know that text is more important than "dead" areas that contain nothing.
This silliness of attributing physical traits to non-physical entities is counter-productive, even if it is very visually appealing.
Lets let go of the overlapping windows crap and solve the division of screen-space problem in a more intelligent way.
I do not understand what you mean by the "most casual observer"... Typically, casual observers of code are coders, so most code can be written to be obvious to them. That means that comments should be used in the rare cases where it is not possible or very difficult.
Believe it or not, eschewing comments because "oh, well, if you want to understand it just read the code" just pisses those of us off who have to come along and clean up your miserable excuse for a codebase... and it sure as hell doesn't prove how studly a programmer you are.
No, programmers should avoid comments for clearer code not because it takes 20 seconds to write them, but because it takes a lot more time to update commented/redundant code and it usually leads to inconsistent and incorrect documentation as the code evolves.
Comments are a form of redundancy to the code as well as testing, static typing, etc. Redundancy has its advantages but it is mostly disadvantageous as it makes changes difficult and in the case it is not automatically checked for consistency (documentation) it usually leads to the lack thereof.
That doesn't mean half your codebase should be comments, but it does mean that you should at least make a passing nod to demystifying your own attempts at cleverness. I have lots of better things to do than to spend all fucking day picking apart your rabbit's nest of code before I can make a change, add a feature or fix a bug.
That's why code should not be clever, it should be simple and as obvious as possible.
People that honestly believe that "if it's well written it doesn't NEED comments" should be strangled with their mousecord and hung in their cubicles as a warning to the rest.
A lot of code can be written as to not require comments for proper understanding. The best documentation of what the code does is the code itself:
Its always up-to-date
Its always completely consistent with the behavior of the program
Its not ambiguous
The EULA is not a legal contract, as no law requires you to agree to the vendor terms in order to use the legally purchased copyrighted works nor does any law give meaning to clicking "I agree" buttons on a computer screen.
and cannot cancel rights granted by the Fair Use doctrine.
Google mostly solves the organizational problem since it organizes the information you need from the entire web according to the criteria you need on demand, at the very moment you request that organization...
Filtering signal from noise is also helped by google, as they measure the amount of links to a site which increases the odds it is not noise. I rarely find blog entries as results for my searches.
Literally saying (to a person) that you agree does mean that you agree (legally) because of verbal contract law.
However, clicking that you agree does not legally mean that you agree and forms no contract under any kind of law.
general purpose memory?
:-)
Or at least swap space instead of the hard disk?
That could be nice, when not playing a game
It is a piece of insignificant text with no legal bearing whatsoever...
Why waste my time reading a document that I did not sign and does not compel me?
(And no, using or clicking "I Agree" does not mean that you actually agree to be obliged by the license, as they try to frighten you to think)