Categories
Technology

Robb’s tops and flops for 2001

Recovered from the Wayback Machine.

John Robb’s posted his Tops and Flops in Technology for 2001. Among the flops, he picked P2P, 3G, Portals, and Open Source. Among the tops he posted Tivo, Wifi, and digital cameras. As you can imagine, there is disagreement with his choices, such as Dive Into Mark.

I also take exception to John’s pick of Open Source and P2P as flops, regardless of his justification that they didn’t live up to their “hype” from 2000.

Yes, P2P did generate a lot of hype, primarily because of Napster. But P2P is not just Napster, or Groove, or any one application. P2P is a concept rather than a specific implementation. P2P is based on the concept of non-centralized Internet access; access that isn’t controlled by an one server or any one entity. If you apply this concept to Internet access today, it could cover email, weblogging, and even web services. It would even cover something like Userland’s Manila. Napster was only one aspect of P2P, and not a great one at that.

As for Open Source, well Mark has it right — John you missed the mark (sorry, pun unintended) with this one. Consider the premise behind open source: groups of people from throughout the world, working on source code for specific projects, in most cases without any expectation of remuneration or even acknowledgement. Now consider the products, as Mark did: Apache, Mozilla, Python, Ant, Linux, and the list goes on. Too much hype? We haven’t hyped these efforts enough! They represent the best of our industry; they represent the best of us. If we measure technology success purely by stock value and profit, then we’re in sad, sad shape. What was it Dave Winer talked about recently? Internet carpetbaggers?

However, I also realize that John is basically a Suit. He reads about trends, and he reads about approaches, and he writes about them, and he makes recommendations, and he manages — but John doesn’t get his hands dirty. He doesn’t get into the technology. He might be called a “technology expert”, but he’s not a techie. So he’s not going to look at Open Source, or even P2P from the ground level. He’ll look at it from a bottom line, or from a spreadsheet, or from the viewpoint of counted lines in publications, or from conversations with techies, but he’ll never have a techie perspective. So, I’m tempted to cut him some slack — he doesn’t really understand the technology. The industry, yes. The business, yes. But not the technology.

December 28th

Robb has pulled the entry with the following statement:

I am beginning to think there isn’t any real intellectual rigor behind the open source movement.

 

Categories
Web

Seven wonders of the web world

Recovered from the Wayback Machine.

Hey, Blogger was listed as one of the seven wonders of the Web world, along with Amazon, Google, eBay, Yahoo, Project Gutenberg, and Multimap. I’m not into online auctions, and I’ve never heard of Multimap, but I’m a big user of Google, I use Blogger for this weblog (at this time), and I subscribe to several Yahoo groups. And I buy at Amazon (though I’ve been going to B & N lately).

Congrats Blogger!

Categories
Internet

First Usenet Postings

Recovered from the Wayback Machine.

I moved today’s original posting to my web site OpEd page — it’s too large for a weblog. I’ll post it later this weekend when I have time to finish it.

In the meantime, I’m still responding to the folks who volunteered for the RDF book tech editing process. Too many good folks have volunteered.

I’m also indulging in a bit of self centered ego tripping — I’m in searching for my first Usenet posting at Google.

I know it was for a Usenet group interested in POSC, ModelPro, data models and schemas, what have you. I also know I wrote the Usenet posting while I was working for Sierra Geophysics, many years ago, in the beginning of the 90’s (I was a late Internet bloomer). But I can’t remember anything more specific, and I still haven’t found it. If I look for “Shelley Powers” I get way too many Usenet postings back — I’ve been opening my mouth online for years.

There’s no use or purpose for finding my first Usenet post — I just want to, for fun and curiosity. Personally, I think it’s great that Google is posting the Usenet Archives, and I’m playing with it.

It’s funny, but who’d have ever thunk it — our old web and internet stuff is now becoming “history”. Geez, makes me feel like an old fart.

Categories
Technology Writing

Practical RDF Tech Reviews

I sent a request for technical reviewers of my book “Practical RDF” to the Semantic Web, RDF Interest, and Jena Interest groups . My hope is that I’ll get volunteers that reflect the book’s targeted audience, and so far I’m getting a terrific response from an incredibly interesting mix of people. In fact, I’m extremely pleased at the response.

This really is becoming the best book I’ve ever worked on. The subject’s interesting, the technology’s great, the diversity of people using the technology is fantastic. I’m very excited about the book.

Scratch that: I’m very, VERY excited about the book.

That’s not all — the Unix Power Tools Third Edition book is starting to move along nicely now. I think the new material reflecting Linux and Darwin will be a great addition to the book.

O’Reilly, I owe ya.

Categories
Technology Writing

Creating C# Applications: Chapter 4

One of the most innovative features of C# is the concept of managed and unmanaged code. It is this that truly differentiates this language from its more commonly used cousins, C++ and Java.

What is unmanaged code? Well, put simply, unmanaged code is any C# code that uses pointers. Conversely, managed code could be considered to be any use of C# that doesn’t include the use of pointers. However, the concept goes beyond these simple statements.

In C++ if you want to work with a block of data, such as a large text string (anything that isn’t a simple scalar value), you must allocate the resources for the string, initialize and use the resource, and then free or deallocate it manually when you’re finished. To pass a reference to the string in a function you wouldn’t need to pass the entire string, but only a pointer to the string’s location in memory, its address. Using pointers is efficient, but one of the problems with manual allocation of resources and the use of pointers is that the developer may forget to free the resource, causing a loss of the resource commonly referred to as a memory leak. After many iterations of the code, the application’s performance can degrade, and may even stop performing.

Java eliminated this problem by eliminating the need to manually allocate and deallocate resources. The Java Virtual Machine (VM) provides the resources necessary to support the application and also provides garbage collection (defined in more detail in the next section) to clean up and free the resources after the application is finished. This approach prevents problems of lost resources but also prevents the use of pointers as the support for garbage collection and pointers are mutually exclusive.

C# eliminates the problem of having to choose between the use of pointers and the associated problems of resource loss, and automatic garbage collection but without support for pointers. The language does this by providing support for both garbage collection and pointers — if you follow rules carefully defined within the language that allows both of these seemingly incompatible capabilities.

In addition to the support for managed and unmanaged code, C# also has other unique concepts available to it based on the runtime language support provided by the Common Language Runtime (CLR), such as the WeakReference wrapper class, useful with larger objects and collections.

First, though, let’s take a closer look in the next section at why the use of pointers and garbage collection are so contradictory. If you already know this, you can skip to the section titled “Managed and Unmanaged code,” following.

Garbage Collection and Pointers

As stated earlier, in a programming language that doesn’t provide automatic management of resources, you must allocate and initialize the resource and then deallocate it when finished. However, when garbage collection is supported, you don’t have to manage the resources as the garbage collection mechanism does this for you.

Within the CLR environment, storage space for a new object is pulled from a managed heap. As a new object is created, it’s allocated space within the heap and an address is assigned to the object that references the starting address of its location in the heap. The object’s given the next available space within the heap that can contain it completely.

The amount of space in the heap assigned to the object depends on the structure of the object. A pointer is used to traverse the heap until a contiguous block of space large enough to fit the object is found.

Garbage collection is used to find objects that are no longer being used and to free up the heap space the object is occupying. In the Common Language Infrastructure (CLI) architecture, the garbage collection mechanism is triggered when the pointer used to search for an available heap location travels past the boundaries of the heap.

During the garbage collection process, the collection mechanism visits each address on the heap, checks to see if the object is still being referenced (can be reached and is therefore accessible by existing process) and then freeing up the space if the object is no longer within the scope of the existing process or application scope. The mechanism also optimizes the heap by shifting the addresses (the pointers) of existing objects to provide contiguous blocks of free space for new objects as they are allocated.

This last statement actually explains why manual creation of pointers and garbage collection are not compatible within the same development environment. You can’t create an object and reference it via a pointer to an address that could then be modified by an automatic garbage collection mechanism, thereby making your reference — the pointer — meaningless.

In addition, in this process the garbage collection mechanism must know how much space an object takes up — its structure — in order to manage it efficiently. In C++, it isn’t unusual to cast a pointer from one object/structure type to another, making garbage collection virtually impossible as the mechanism wouldn’t be able to determine the exact structure of the object, and therefore how much space is needed or occupied.

The problem of using pointers and garbage collection in one language is solved through the use of managed and unmanaged code, discussed next.