- Table of Contents
- .NET Book Recommendations
- What Is .NET?
- The Microsoft .NET Framework
- The Common Language Runtime (CLR), the Common Type System (CTS), and the Common Language Specification (CLS)
- .NET Framework Class Library
- Visual Studio .NET
- .NET Enterprise Servers and .NET My Services
- .NET Compliant Languages
- C#
- Visual Basic .NET (VB .NET)
- ASP.NET
- XML Web Services
- ADO.NET
- XML.NET
- Windows Forms
- Why .NET?
- Displaying Errors with the Error Provider
- COM Interoperability
- Comparing Java and .NET
- Calling Unmanaged Code
- .NET Application Security
- Code Access Security
- .NET Standards Support
- Numeric Types in the .NET Framework
- Working with Strings
- Formatting Strings
- Trimming Character Strings
- Comparing Strings in .NET 2.0
- Arrays and Collections
- Arrays as Class Members
- Sorting a Multi-Dimensional Array
- Sorting a Multi-Dimensional Array with LINQ
- File I/O (System.IO)
- Working with File Names
- Using the File System
- Working with Files and Directories
- Monitoring the File System
- Working with Streams
- Working with Text Encodings
- Working with Date and Time
- Extending the DateTime Class
- Fun with Dates
- Exceptions
- Delegates
- Events
- Asynchronous Programming
- Asynchronous File I/O
- Timers
- Random Numbers
- Cryptographically Secure Random Numbers
- Serialization
- MultiThreading (System.Threading)
- Multi-Threading Overview
- The Managed Thread Pool
- Managed Threading
- Thread Synchronization
- Synchronizing Data Access
- Trace Debugging
- Tracing in .NET 2.0
- ASP.NET Trace
- Validating User Input in ASP.NET Web Pages
- Event Logging
- Monitoring Application Performance
- Accessing the Registry
- Accessing Environment Information
- Environment Variables in .NET 2.0
- Managing Windows Forms Applications
- Working with Email
- Working with Graphics
- Animating a Background
- Working with Images
- Drawing Cycloid Curves
- Simulating the Spirograph
- Building International Web Applications
- .NET Compact Framework
- Mobile Web Development with ASP.NET
- Speech Technologies
- Microsoft MapPoint Web Service
- Working with Typed DataSets
- Using Relationships in DataSets
- DataColumn Expressions
- Playing Simple Sounds
- Playing Sounds with .NET 2.0
- Returning an Image in a Web Page
- RSS
- Best Practices Project Structure
- Best Practices Application Blocks
- The Data Access Application Block
- The Exception Management Application Block
- Best Practices — Performance
- Best Practices — Performance and Scalability
- Best Practices - Testing
- Reading the Tea Leaves, 2005
- Predictions: A Look Back at 2005, and a Look Ahead to 2006
- .NET Downloads
- Application Deployment Overview
- Application Deployment — Versioning
- Application Deployment — Version Policy
- Application Deployment — Packaging and Distribution
- .NET Remoting Overview
- A Remoting Demonstration
- Remoting Configuration
- Remoting: Lifetimes and Leases
- Remoting: Other Issues
- Attributes
- Writing Custom Attributes
- Accessing Attributes in Code
- Reflection
- Class Design: Inheritance, Interface, or Composition?
- The TriTryst Game
- Console Applications in .NET 2.0
- New File I/O Methods in .NET 2.0
- Building Projects with MSBuild
- Unmanaged Callbacks in .NET 2.0
- Timer Troubles
- Non-Rectangular Windows Forms
- Windows Forms Transparency
- 10 Things I Hate About Visual Basic
- 10 Things I Hate About C#
- Background Processing with Idle Time
- Scaling Windows Forms
- Reading and Writing Binary Data
- New Memory Management Functions in .NET 2.0
- Compatibility Between .NET 1.1 and .NET 2.0
- Managed Debugging Assistants in .NET 2.0
- XDir: A Program for Viewing Directory Sizes
- The Microsoft.VisualBasic Namespace
- Operator Overloading
- Working with GPS Data
- Hidden Visual Studio Tools
- .NET 3.0
- The .NET 2.0 Stopwatch Class
- Nullable Types
- Drawing Rotated Text
- Unsafe Code
- Other .NET Languages
- Compiler Directives
- Safe Handles
- Predictions, 2007 Edition
- New Features in C# 3.0
- Generics
- Network Client Programming
- On the Misuse of Exceptions
- Maximum Object Size in .NET
- More on Maximum Object Sizes
- Keyed Collection Memory Limitations
- Matching String Endings
- Allocating Small Data Structures
- Grumbling About Limitations
- Some Thoughts on the Nature of What We Do
- Working with Predicates in Collections
- Working with DataReaders
- Outputting XML with XmlWriter
- Writing XML Data
- Working with Compression
- Another Look at Compressed Streams
- Compressing a Very Large File
- Canonical URIs
- Constructing URIs
- Using OneWayAttribute for Remote Calls
- Selecting a Garbage Collector
- Linked List
- Linked List Application - The MRU List
- Auto-implemented Properties in C#
- The HashSet Collection
- Looking Ahead: 2018
- An Experiment in Optimization
- A Larger Integer
- Extension Methods
- Language Integrated Query (LINQ)
- Variable Length Parameter Lists
- The ReaderWriterLockSlim Synchronization Primitive
- Sorting a Text File
- Sorting a Large Text File
- Using ListView with Large Data Sets
- LINQ One-Liners
- Regular Expression Optimization
- Random File I/O
- Computing the Size of a Structure
- More on Computing Structure Sizes
- UnmanagedMemoryStream
- Dynamically Loading Code
- Building a String Table
- Delegates Versus Function Pointers
- Visual Studio Editor Features
- A Simple Profile Timer
- New Features in C# 4.0
- IEnumerator or IList?
- New Features in .NET 4.0
- Set Operations with IEnumerable and HashSet
- Using File Locks
- Extending Object Functionality
- Clearing a HashSet
- When Hash Codes Matter
- Parsing Command Line Options
- Creating a Single-Instance Program
- Asynchronous Windows Forms Events
- The BackgroundWorker Component
- Fixing a Dumb Mistake
- Thinking About Multi-Threaded Programs
- JavaScript Object Notation
- Useful .NET-related Sites
- Markov Models
- Building an Order 0 Markov Model
- Higher Order Markov Models
- Webmaster's Guide to robots.txt
- An Overview of the Parallel Extensions to .NET
- Parallel Extensions Synchronization Objects
- Thread Safe Collections
- A Bug and a Conundrum
- Another Bug and an Answer
- Task Parallel Library
- Good and Bad Ideas in C#
- Parallel LINQ
- Copying Large Files
- Replacing File.Copy
- Learning from Our Mistakes
- Symbolic Links
- There Is No Easy Fix
- Tracking Hurricanes
- Examining Hurricane Data
- Searching for Multiple Strings
- Simple JSON Processing
- Aho-Corasick String Searching
- Writing a Web Crawler
- Web Crawler Politeness
- Source Control Management
- Subversion
- Communicating with Datagrams
- Fun with Actions and Funcs New
- The Future of Media
- The Importance of Metadata
- Of Comparison and IComparer
- IComparer, Comparer, IComparable, Oh My!
- Comparing Generic Types New
- A Simple HTTP Server New
- Informit Reference Library
Predictions: A Look Back at 2005, and a Look Ahead to 2006
Last updated Jan 6, 2006.
Once again we come to the time of year when I’m asked to revisit my predictions from the year before to see how I did, and to make some predictions for the current year. So, without belaboring the point, let’s start with how I did for 2005.
Reviewing 2005 Predictions
My first prediction last year was what I thought was a no-brainer: that we would see a critical mass of .NET-enabled machines in the hands of end users. My thinking there was that companies and individuals who had been using the same computers for the last four or five years would finally break down and spend the money to upgrade their systems, and in the process install the .NET Framework. At the time, I was under the impression that the Framework was included in the Windows XP SP2 upgrade so that people who upgraded to SP2 would automatically be .NET enabled.
Even with all the grumbling about SP2, most people have upgraded. It’s harder to say whether many users have the .NET Framework now. I think they do, although many don’t know it. We have passed the "critical mass" stage now, where a large number of users are .NET-enabled. End user applications are beginning to appear, but not with the speed that I had expected.
On the business side, most companies that were developing in Visual Basic 6 or ASP have moved their new development to .NET. Many are migrating their old systems to .NET, too. Although begun in 2002 and 2003, that migration really picked up speed in 2005. With the release of .NET 2.0, most of the holdouts from the VB 6 days will now move to .NET.
Predicting the release of Visual Studio 2005 and .NET 2.0 was no great feat, although I somehow expected it to be before late November. We have the tools now. Time will tell if we use them correctly.
I went out on a limb to predict the wide acceptance of 64-bit computers and installation of the 64-bit version of Windows. It seems that only a few power users have upgraded to 64-bit machines, and even fewer have installed the new Windows version. It’s hard for users to see a benefit to 64-bit computing, especially when their 2 GHz Pentium machines do whatever they want very quickly and at half the price. As far as personal computers go, I think 64-bit machines will continue to be power users’ toys for the next few years.
Data centers, though, will start to buy 64-bit machines in greater numbers in order to take advantage of the higher speed and greater memory addressing range. This, too, will be a slow process.
One thing that I totally missed last year was the exploding popularity of notebook or laptop computers. More new notebooks than desktops were sold in May, and the numbers continue to grow. Notebooks have finally reached the point where they are powerful enough for everyday use and the prices have come down under the $1,000 mark so that people find them affordable. Desktop machines still are more powerful and less expensive, but they’re not nearly as convenient as notebooks are. This is one trend that I expect to continue.
Predictions for 2006
I’m notoriously bad at making predictions, especially for the near future. I like to look ahead five or ten years to spot general trends, but my crystal ball is terribly cloudy when asked for specifics for the coming year. That said, here are a few predictions for 2006.
Windows Vista (what was code named Longhorn) will ship on July 23, as Microsoft has announced. I know that they’ve pushed the release date out a number of times over the years, but this date is so close that I find it unlikely that they’ll move it again.
The effect of Windows Vista will be small for at least a year following its release. Although Vista has many new and useful features, I don’t think there’s anything there that will entice many people to upgrade or to go out and buy a new computer. Windows Vista will undoubtedly replace Windows XP, but it will take a few years, especially in corporations that have a large installed base of XP computers.
The release of Windows Vista will be a boon to developers of .NET software because it will be the first user-oriented operating system that has the Framework built in. Developers will be able to ship a .NET application and not worry about having to ship the Framework or instruct users how to obtain it. Again, this won’t be a great benefit overnight unless you’re developing specifically for Windows Vista.
Expect a quick and large migration from Visual Studio .NET 2003 to Visual Studio .NET 2005. There will be a few holdouts, but most developers will be quick to move to the new version. The many productivity enhancements, plus major additions to the Visual Basic .NET and C# language and the underlying framework are huge incentives to migrate. Although .NET 2.0 is mostly backward compatible with .NET 1.0 and .NET 1.1, there are differences. I think users and developers alike will want to move quickly beyond those earlier versions and standardize on .NET 2.0, which is the same version that will ship with Windows Vista.
On a related note, I expect the last of the Visual Basic 6 and COM holdouts to finally move to Visual Studio 2005. There will undoubtedly be some continuing COM development (mostly maintenance of legacy systems) for some time, but I expect almost all new application code to be written in .NET. It’s simply a better platform with better tools, and much more productive than Visual Interdev or older versions of Visual Studio.
Last year I predicted that programmers wouldn’t see much different--just new and better tools to do the same old thing. I also predicted that end users would begin to see new classes of applications and interesting ways to put their computers to use. The first was a no-brainer, and I think that holds true for this year, as well. Developers will have better tools, faster computers, and do pretty much the same thing that they’ve been doing. Sadly, I think the same is pretty much true for end users. Beyond Windows Vista, I don’t see anything particularly new and exciting happening in user space over the next year.
It seems all the excitement recently has been in specialty devices, specifically the iPod and its clones. I think that will continue, much as the Palm Pilot craze grew a few years ago. The iPod is more than a passing fad, but for now it’s almost purely an entertainment device. It remains to be seen whether such devices can make the transition to being truly useful, or if the iPod can become the next mobile phone: something that simply everybody has to have, whether or not it’s actually useful. We won’t find the answer to that this year, but I think we’ll start to get a better idea.



Account Sign In
View your cart