Computers:

Shelby wrote:I just finished a discussion with an expert. And now I think I understand why this problem has not been fixed and never will be fixed.

The geeks who make the worlds open source software, which includes most internet software, love Linsucks and hate McSh8's Windoze. They want to see Windoze perish in its own insecurity. And McSh8 also wants its Windoze to get many viruses, because it makes people want to upgrade to new and improved versions (and often buy a new computer at same time, so hardware vendors also like more viruses).

The more viruses, the more everyone in the industry profits.

So nobody has an incentive to provide you the customer with something that works properly.

Shelby wrote:Firefox will try to fix this problem (but I don't know when):

https://bugzilla.mozilla.org/show_bug.cgi?id=588704#c47

Shelby wrote:I think there are far too many cases where we chase the shadows, instead
of real holes and solutions. And this is destroying the
freedom/opportunities on the internet in my opinion (will end up with the
big server farm companies being the only ones whitelisted and rest of us
in slavery).

For example, the whole concept of firewalling everything and then
whitelisting the internet. That isn't security, it is just a way of
letting only the viruses come in and not the useful programs. When
programs have to written with STUN tunneling like a virus, the internet is
fundamentally broken by Almost-Better-Than-Nothing security models. So now
99% of the possible internet connections are unavailable unless one writes
their program like a virus...

Type inference errors should be better programmed to illustrate the solution tree in code.

Untyped languages can not be referentially transparent, which is required for massive scale composability and parallelization (think multi-core and virtual mesh networking).

Adaption (evolution) to dynamic change requires the maximum population of mutations per generation, i.e. independent actors.

Copute the dots.

shelby wrote:It is fascinating to think of networks this way. The neurons in the brain, people in society, cities on the interstate highways, telephones in the telephone network, computers connected to the internet, hyper-links within web pages, are all interacting nodes of a massively parallel network.

Then it is interesting how the constraints effect (cause) the topology of the network, and then further contemplate how constraints can be destroyed, so as to exponentially increase the information content of society. I think such destruction mechanisms are often referred to as disruptive technology.

For example, think of how distance cost affects road networks, which is also the topology of the internet. You end up with clusters of massively parallel local connections, and then multiple large backbones connecting these.

Note how the internet has broken down the constraint of distance between people. Note how the wikipedia concept of editable web pages (which is what myspace is on a social collaboration level) has broken down the constraint of time and place to collaboration.

This theory is so powerful, it tells me precisely how to focus my work in order to become exponentially more effective on destroying the topological constraints to maximizing the information content of society (and thus on my wealth and knowledge and prosperity).

dash, I think you need to think more of your machine intelligience in terms of breaking down constraints in the potential network of real people, so that they can experience more interactions, without the material constraints.

David Harrison, Ph.D.: CTO, Co-Founder
David Harrison is Chief Technology Officer and co-founder. Prior to Flingo, he was the founder of BitTorrent.org and invented BitTorrent's Streaming protocol. David Harrison previously held a post-doctoral position in the Video and Image Processing Lab in the Electrical Engineering and Computer Sciences Department at UC Berkeley. He received a Ph.D. in Computer Science from Rensselaer Polytechnic Institute.

In March 2010, the website Business Insider ran a story—surprisingly under-circulated—in which sources (Business Insider got access to instant messages and emails, and conducted “more than a dozen” interviews) claim that Mark Zuckerberg, anxious about an upcoming article on the ConnectU scandal, hacked into the email accounts of two Crimson reporters, using login data he found by applying failed thefacebook.com passwords to Harvard email accounts. Later that summer, Business Insider sources show him hacking into ConnectU founders’ email addresses, forming fake Facebook profiles, and tinkering with the ConnectU site.

Business Insider also has an instant-message exchange that supposedly took place between Zuckerberg and a friend in February 2004, in which Mark boasts about all the private information he’s gleaned as Facebook czar, and calls the Harvard students that trust him “dumb fucks.”

Shelby wrote:Obviously the Knuth books are great.

Code:

/* by Shelby H. Moore III, Created: Nov. 2008, Last Updated: Nov. 2008
   I make no claims nor warrents whatsoever. Please retain this header with my name in all copies.
   Please kindly credit me in any derivative works.
*/
package huffman;
import Assert;
import huffman.RWbits;

// See tutorial at end of this file
class LeafCode
{
   public var bitcount   (default, null) : Int;
   public var code      (default, null) : Int;
   public function new( _bitcount : Int, _code : Int )
   {
      bitcount = _bitcount;
      code = _code;
   }
}


// value of the leaf (decoded from the LeafCode)
typedef LeafValue = Value;


class Tree
{
   private var leaves   : Array<UInt>;
   private var values   : Array<Int>;
   private var map      : Array<LeafCode>;   // map[LeafValue.value] = LeafCode, map.length == 0 if not initialized
   private var invmap   : Array<Array<Null<LeafValue>>>; // map[LeafCode.bitcount][LeafCode.code] = LeafValue, map.length == 0 if not initialized
   private var rwbits   : RWbits;

   // leaves[i] = number of Huffman sub-trees of length i bits, starting from root that end at LeafCode (value not node)
   // values = values of leaves in the order that corresponds to for( i in 0...leaves.length ) leaves[i];
   public function new( _leaves : Array<UInt>, _values : Array<Int>, _rwbits : RWbits )
   {
      leaves = _leaves.copy();
      values = _values.copy();
      // Remove useless 0 elements at end
      while( leaves[leaves.length - 1] == 0 )
         leaves.pop();

      map = new Array<LeafCode>();
      invmap = new Array<Array<Null<LeafValue>>>();
      InitMaps();

      rwbits = _rwbits;
      Assert.IsTrue( rwbits.rwcount >= leaves.length );
   }


   // Algorithm presented on page 50 of http://www.w3.org/Graphics/JPEG/itu-t81.pdf (CCITT Recommendation T.81)
   /* To visualize, leaves = [0, 0, 1, 5, 1, 1, 1, 1, 1, 1] for following LeafCodes:
         00
         010
         011
         100
         101
         110
         1110
         11110
         111110
         1111110
         11111110
         111111110
   */
   public function InitMaps()
   {
      if( map.length != 0 && invmap.length != 0 ) return; // Already done?
      var code = 0;
      var n = 0;
      var start = 1; // skip leaves[0] because ***footnote below
      var max = start + 1;
      for ( i in start...leaves.length )
      {
         invmap[i] = new Array<Null<LeafValue>>();
         Assert.IsTrue( leaves[i] <= max ); // leaves[i] can't have more values than can fit in i bits
         for ( j in 0...leaves[i] )
         {
            var t = code /* we mask here instead of in reading and writing of bits*/& (max - 1);
            map[ values[n] ] = new LeafCode( i, t );
            invmap[i][t] = new LeafValue( i, values[n] );
            n++;
            code++;
         }
         code += code; // code <<= 1, code *= 2
         max += max; // max <<= 1, max *= 2
      }
   }
   // ***always node (not a leaf) at root (top) of huffman tree, see tutorial at bottom of this file


   // Returned LeafCode.num_bits <= leaves.length
   public inline function Encode( value : UInt )
      : LeafCode
   {
      return map[value];
   }


   // Inputs bitcount significant bits (or less for last bits of encoded stream), where LeafCode is in the most significant bits
   // If bitcount < leaves.length, will not match LeafCode.bitcount > bitcount
   // Returns null if input matches no LeafCode
   public function Decode( bits : Int, bitcount : Int )
      : Null<LeafValue>
   {
#if table_walk_method_to_Tree_Decode
      var code = 0;
      var n = 0;
      //var start = 1; // skip leaves[0] because ***footnote above
      var max = 2; // start + 1
      var mask = bitcount; // bitcount + 1 - start
      for ( i in /*start*/1...bitcount )
      {
         mask--;
         var t = leaves[i];
         if( t != 0 )
         {
            n += t;
            code += t;
            var candidate = bits >>> /*bitcount - i*/mask;
            if( candidate < (code & (max - 1)) )
            {
               var copy = code;
               for( j in 1...t+1 )
                  if( candidate == (--copy & (max - 1)) )
                     return new LeafValue( i, values[n-j] );
            }
         }
         code += code; // code <<= 1, code *= 2
         max += max; // max <<= 1, max *= 2
      }
#else
//return new LeafValue( 32, bits );
      //var start = 1; // skip leaves[0] because ***footnote above
      var mask = bitcount; // bitcount + 1 - start
      for ( i in /*start*/1...bitcount+1 )
      {
         mask--;
         var leaf = invmap[i][bits >>> /*bitcount - i*/mask];
         if( leaf != null )
            return leaf;
      }
#end
      return null;
   }


   public inline function WriteEncoded( value : Int )
   {
      var leaf = Encode( value ); // make sure Encode() isn't called twice if Write() is inline and not optimized
      Write( leaf );
   }


   // Input must be w.bitcount <= rwbits.rwcount, which is assured if w = Tree.Encoded()
   public inline function Write( w : LeafCode )
   {
      rwbits.Write( w.bitcount, w.code );
   }


   public inline function ReadDecoded()
      : Int
   {
      return rwbits.ReadDecoded( Decode );
   }


   // Same restriction on input value, as for Tree.Write()
   public inline function Read( bitcount : Int )
      : Int
   {
      return rwbits.Read( bitcount );
   }
}

/* http://www.siggraph.org/education/materials/HyperGraph/video/mpeg/mpegfaq/huffman_tutorial.html
A quick tutorial on generating a huffman tree
Lets say you have a set of numbers and their frequency of use and want to create a huffman encoding for them:

  FREQUENCY       VALUE
  ---------      -----
       5            1
        7            2
      10            3
      15            4
      20            5
      45            6

Creating a huffman tree is simple. Sort this list by frequency and make the two-lowest elements into leaves,
creating a parent node with a frequency that is the sum of the two lower element's frequencies:

       12:*  <--- node
       /  \
    5:1  7:2  <--- leaves

The two elements are removed from the list and the new parent node, with frequency 12, is inserted into the list by frequency.
So now the list, sorted by frequency, is:

      10:3
      12:*  <--- inserted tree node
      15:4
      20:5
      45:6

You then repeat the loop, combining the two lowest elements. This results in:

       22:*
       /  \
  10:3  12:*
   /      \
 5:1      7:2

and the list is now:

      15:4
      20:5
      22:*
      45:6

You repeat until there is only one element left in the list.

       35:*
       /  \
  15:4  20:5

      22:*
      35:*
      45:6

             57:*
         ___/    \___
      /            \
    22:*          35:*
    /  \          /  \
 10:3  12:*    15:4  20:5
        /  \
      5:1  7:2

      45:6
      57:*

                                  102:*
                __________________/    \__
              /                          \
             57:*                        45:6
         ___/    \___
      /            \
    22:*          35:*
    /  \          /  \
 10:3  12:*    15:4  20:5
        /  \
      5:1  7:2

Now the list is just one element containing 102:*, you are done.

This element becomes the root of your binary huffman tree. To generate a huffman code you traverse the tree to the value you want,
outputing a 0 every time you take a lefthand branch, and a 1 every time you take a righthand branch.
(normally you traverse the tree backwards from the code you want and build the binary huffman encoding string backwards as well,
since the first bit must start from the top).

Example: The encoding for the value 4 (15:4) is 010. The encoding for the value 6 (45:6) is 1

Decoding a huffman encoding is just as easy : as you read bits in from your input stream you traverse the tree beginning at the root,
taking the left hand path if you read a 0 and the right hand path if you read a 1. When you hit a leaf, you have found the code.
*/

Shelby wrote:I wrote a huffman encoder in HaXe (Flash, etc) for JPEG in 2008

Shelby wrote:I wrote a huffman encoder