Welcome to MSDN Blogs Sign in | Join | Help

Sensors in my Pocket PC

I like to play around with the occasional new Microsoft technology, and since I recently traded my old Treo for an HTC Touch Pro, it seemed like it might be fun to check out the onboard accelerometers.

Fortunately, courageous bloggers have probed the secrets of HTCSensorSDK.dll, culminating in the .NET wrapper by Koush. This makes developing a mobile app that uses the device’s sensors a snap.

My first thought was to see what the data stream from the sensors looks like, so I wrote a primitive real-time graphing app by using the Windows Mobile 6 SDK. The WinMo SDK has nice integration with Visual Studio, so it’s painless to create a Smart Device project.

Koush’s sample code is great, and it was easy to adapt it to draw waveforms. Here’s the app in the designer:

The TiltData main form in the Visual Studio designer.

The TiltData main form in the Visual Studio designer.

There are three panels, one for each component of the tilt vector. The tilt vector is the vector, in device space, that measures the alignment of the device relative to the gravity vector. When the device is held upright, the Y value is maximum (at around 9.8, units are m/sec/sec), and the X and Z values are zero.

To produce some interesting signal, I taped my phone to the spokes of a bicycle wheel. Here are the traces that result from a good spin:

TiltData running on my HTC Touch Pro.

TiltData running on my HTC Touch Pro.

The X-Y plane of the phone is parallel to the radial plane of the wheel, which is vertical. Most of the signal shows up as oscillations in the X-Y plane, but some Z-axis wobble is detectable. 

Code is here. You’ll need Visual Studio 2008 SP1, Windows Mobile 6 SDK, and Koush’s Windows Mobile Unified Sensor API. Add Koush’s Sensors project to the TiltData Solution, compile, and deploy to your device. I don’t recommend swinging it around by the USB cable, by the way.

Microsoft and Earth Week

CoverImageI have to say I’ve been impressed with Microsoft’s recent efforts to green up. All the cafeterias have compostable dining ware now – it’s quite a blast to dump everything on my tray into a single receptacle labeled “Compost.”

Now Microsoft is publicly announcing new technologies for managing power consumption.

Check out TechNet magazine’s “Going Green” issue.

Also, Microsoft’s Environment site has been updated for Earth Week. The revisions reflect the following content and technology updates:

Steve Ballmer has committed Microsoft to reduce its corporate carbon footprint by 30% by 2012. I hope to see solar panels and green roofs on campus buildings by then!

Microsoft Dynamics

Live streaming from MIX ‘09

Don’t miss the live stream from MIX ‘09. Scott Guthrie is on right now. Lots of exciting new announcements coming today.

 

image

Posted by jgalasyn | 1 Comments

WPF and the Parallel Extensions

It’s been over six months since the Parallel Extensions to .NET Framework 3.5, June 2008 CTP release, and I’ve been wanting to play around with that stuff for awhile. It’s all shipping in .NET Framework 4.0 and is considered by Soma to be a key cloud-enabling technology. So I finally jumped in and decided to “parallelize” the reaction-diffusion visualizer I discussed in Using WriteableBitmap to Display a Procedural Texture.

Here’s a snapshot:

image

Reaction-diffusion visualizer

My first implementation used a single worker thread to compute each frame. Here’s how the single-thread implementation uses the CPU resources on my dual-core Inspiron laptop. Frame time averages about 127 ms.

 

image

One processor is at nearly 100% usage, but the other is underutilized. 

To parallelize my reaction-diffusion visualizer, I simply replace the outer for loop with a Parallel.For method call:

            //for (int i = 1; i < vesselHeight - 1; i++)
            Parallel.For(1, vesselHeight - 1, i =>
            {
                for (int j = 1; j < vesselWidth - 1; j++)
                {
                    c = -W1 / weight(2, i, j, reaction);
                    f = -W2 * weight(1, i, j, reaction);

                    e_to_c = Math.Exp(c);
                    e_to_f = Math.Exp(f);
                    d = 1.0 + K1 * e_to_c;
                    g0 = (K1 * K2 * e_to_c * e_to_f) / d;
                        
                    Xc = b * (g0 / (g0 + 1));
                    Xb = (K1 * e_to_c / (1 + K1 * e_to_c)) * (b - Xc);
                    Xa = b - Xb - Xc;
                    // The out buffer is shared among processors/threads.
                    reactionOut[2, i, j] = Xc;
                    reactionOut[1, i, j] = Xb;
                    reactionOut[0, i, j] = Xa;
                }; 
            }); 

Of course, it can’t be quite this simple. Here’s the output after a few frames:

 

image

Reaction-diffusion visualizer with thread contention

The problem, of course, is that access to the out buffer, reactionOut, is not synchronized (Not so! See UPDATE below). I can put the inner loop inside a lock, and this produces correct behavior again, but the frame rate is actually slower than in the single-thread case.

Fortunately, it’s easy to solve the problem without the performance penalty caused by lock overhead. I factored the inner loop code into a ComputeConcentrations method – I hadn’t done this before, because I didn’t want the method-call overhead.

            //for (int i = 1; i < vesselHeight - 1; i++)
            Parallel.For(1, vesselHeight - 1, i =>
            {
                for (int j = 1; j < vesselWidth - 1; j++)
                {
                        Concentrations c = ComputeConcentrations(i, j, reaction);
                        reactionOut[2, i, j] = c._Xc;
                        reactionOut[1, i, j] = c._Xb;
                        reactionOut[0, i, j] = c._Xa;
                }; 
            }); 

Now the output is correct and both cores are fully engaged. Frame time averages about 83 ms, which is a 35% improvement.

 

image

Now I need to get my hands on a quad-core machine.

UPDATE: Stephen Toub, lead PM for our concurrency development platform team, kindly reviewed my code and corrected my misconception about access to the out buffer. In fact, the problem is with closure; specifically, I had declared all my variables outside the outer loop. This meant that all threads were sharing those registers, which is almost never what you want. The colors were pretty, though.

UPDATE 2: Here’s the same code running on my 3.6GHz quadcore. Average frame rate is 62ms, which is slightly over 50% faster than the 2GHz single-thread case.

RD Performance

 

Posted by jgalasyn | 1 Comments

A simple particle system

For no obvious reason, I had a sudden need to write a particle system that simulates a Maxwell-Boltzmann gas, which forms the basis for the kinetic theory of gases. The trick is to implement momentum-conserving collisions as the particles bang into each other. When setting the initial conditions, the particles get uniformly random velocity vectors. The cool and somewhat counterintuitive result is that regardless of the initial conditions, the system equilibrates to the asymmetric Maxwell-Boltzmann distribution, shown in the histogram below. The histogram shows the cumulative number of particles binned by speed. The colors follow a heat map, with the fastest particle speeds rendered with the hottest colors.

Maxwell-Boltzmann gas

Colliding particles and histogram of speeds.

Here's what the particle speed distribution looks like for four different kinds of atoms. My particles are qualitatively most similar to Xenon atoms and therefore model heavier atoms (those with higher atomic number).

Maxwell-Boltzmann noble gases

The speed probability density functions of the speeds of a few noble gases at a temperature of 298.15 K (25 °C).

Just something to entertain myself while we're snowed in.

Posted by jgalasyn | 1 Comments

Silverlight designer extensibility

I haven't even started writing the docs for SL designer extensibility, and here's Justin Angel with a great blog post that's worthy of the Visual Studio documentation. Maybe I can steal it without anybody noticing...

Siverlight Design Time Extensibility

 

image

A custom editor running in Blend.

Posted by jgalasyn | 1 Comments

WPF developers take note: WPF Designer Hotfix is posted

If you're writing WPF code, be sure to run the new Hotfix.

Details at the WPF SDK blog.

Posted by jgalasyn | 1 Comments

Visualizing Climate Data in Phase Space, Part 2

I promised in an earlier post to implement a visualizer for Poincaré sections. This is a new feature for my phase-space visualizer, and it displays a cross-sectional view of a (usually) tangled phase-space trajectory. If you haven't read the first post, you might want to, or the following discussion will make absolutely no sense.

A Poincaré section is a slice through phase space. It can reveal interesting structures, called attractors, which constrain the orbits through phase space. The following diagram shows a Poincaré section with two different orbits: one is periodic and intersects a single point on the section repeatedly; the other is non-periodic and intersects at many different points.

 

A Poincaré section, or map

[Credits : Encyclopædia Britannica, Inc.]

A Poincaré section in phase space (Encyclopedia Britannica).

The periodic signal has a fixed-point attractor. The non-periodic signal may have one of any number of attractors. If the signal is chaotic, the attractor will appear as a fractal distribution on the Poincaré section. These are commonly called strange attractors. If everything were to come together perfectly, I'd hope to see something like the following attractors in my insolation sections:

 

Fractal ("strange") attractors revealed in Poincaré sections.

 

Keep in mind that "chaotic" does not mean random; it refers to randomlike variations that are purely deterministic, but sensitive to initial conditions. Chaotic oscillations occur in systems with nonlinear feedbacks, and Earth's climate system definitely fits this description.

In Part 1, I embedded climate data in a three-dimensional phase space and looked for interesting patterns. There were tantalizing hints of structure, but no smoking gun. The data sets generated by Dr. Raymo were too short for much detail to be visible in a Poincaré section, so I needed to generate my own.

I especially wanted to look for attractors in the insolation signal. Insolation drives Earth'[s climate system, and understanding this input signal gives us a better chance of understanding the system's response to it. In particular, if we can show that the input signal is chaotic, we can expect to find chaotic oscillations in the climate system's response.

The insolation signal is generated from a mathematical model of Earth's orbital dynamics. Dr. Raymo kindly pointed me to a handy Mac implementation named AnalySeries, so I didn't have to reverse-engineer a FORTRAN implementation named Insola. To see any interesting patterns in a Poincaré section typically requires a very large data set, so I used AnalySeries to generate 100 million years of data. Data points occur at 1000-year intervals, so there are 100,000 data points. The 3D phase-space portrait with an embedding delay of 7 samples (7,000 years) looks like this:

 

 NH insolation phase portrait 100mybp delay 7

Phase space portrait of 100 million years of insolation data.

 

Not very helpful. But if we take a slice along the XY-plane, we may see more detail. The following images show the Poincaré sections for two phase-space portraits, with 6- and 7-sample embedding delays. Each orbit makes a dot when it crosses the plane. Downward-traveling crossings make an orange dot, and upward-traveling crossings make a yellow dot. There are 9063 crossings shown in each of the following Poincaré sections.

 

poincare map 100mybp delay 6 poincare map 100mybp delay 7

Poincaré sections for delays of 6 samples (left) and 7 samples (right).

Here are the sections along the YZ-plane:

poincare map YZ 100mybp delay 6 poincare map YZ 100mybp delay 7

Poincaré sections along the YZ-plane for delays of 6 samples (left) and 7 samples (right).

 

I find these sections to be highly suggestive of fractal structure, but there's nothing as clear as in the previous example plots. A fractal attractor might be more visible with a longer data set, but unfortunately AnalySeries generates only 100 million years of insolation data.

All is not lost, however. It's possible visualize the flow by rotating the Poincaré section around an axis and animating the intersection points as it moves. This isn't hard in principle, but it requires more coding. Because the data set is so large, realtime animation is out of the question, so I need to make a WMV out of successive snapshots. That's some more coding. I'll get back to you when I have something that works. 

Posted by jgalasyn | 1 Comments

WPF Chrome deep dive

If you're interested in implementing custom chrome in your WPF application, check out Joe Castro's new post at the WPF SDK blog. Drawing in the non-client with Glass, extending the Glass frame in IE7, and more cool stuff is possible by burrowing under WPF into the Windows API to access DWM.

Here's the kind of thing Joe's code enables:

 

joe7 

joe8

Don't you wish your apps could look like that? Now they can, and without a huge amount of coding.

Get it here.

Posted by jgalasyn | 1 Comments

XamlpadX 4.0 now available

Lester Lobo has posted the latest version of the excellent XamlpadX utility here. This is a must-have for anybody who's doing serious XAML development.

 

xamlpadx screenshot

Posted by jgalasyn | 1 Comments

Visual Studio 2008 SP1 Docs Are Live on MSDN

The latest versions of the VS and .NET documentation are available on MSDN. Don't forget that MSDN is wiki-riffic -- you can add your own comments at the bottom of each page, in the Community Content section.

WPF Designer docs are here.

WPF docs are here.

Posted by jgalasyn | 1 Comments

Visual Studio 2008 SP1 and .NET Framework 3.5 SP1 are Live

Go forth and download:

A few value-adds:

  • The .NET Client Profile, which drastically reduces the size of the .NET Framework (by over 86%!) to allow for ease of deployment for .NET applications
  • Support for SQL Server 2008 both in Visual Studio and through features such as the ADO.NET Data Services and ADO.NET Entity Framework
  • Multiple enhancements to ASP.NET and TFS.  The performance and reliability issues we fixed in Visual Studio gives increased productivity to all developers.
Posted by jgalasyn | 0 Comments

Visualizing Climate Data in Phase Space

I've been reading the online draft (pdf) of Ray Pierrehumbert's excellent new book on climate science, Principles of Planetary Climate. On page 54, there's a nice graph of ocean 18O isotope levels over the past four million years. Using this data, we can infer how much of the planet's water was bound up in ice, as a function of time. The graph reminds me of the kind of trace you get from a nonlinear system that's in a chaotic state, so it seems like a neat idea to visualize this data in phase space. You may remember earlier posts of mine (here and here) on this subject.  Previously, I used music as a real-time input to a phase-space visualizer. This time, I decided to whip up a quick-and-dirty WPF PhaseSpaceControl class to view climate-related data in phase space.

A quick search brought me to Dr. Maureen Raymo's site, which has a convenient archive of climate data. Dr. Raymo constructs a model of 18O isotope levels over the Pliocene/Pleistocene epochs, from three million to one million years ago (1). She uses a model of ice volume that's driven by the computed insolation (amount of solar energy) at Earth's surface. Insolation varies deterministically with Earth's distance from the sun, with Earth's wobble as it spins (precession), and with Earth's axial tilt (obliquity).

This adds up to the following insolation in the Northern Hemisphere (NH) and Southern Hemisphere (SH) computed for the two million-year period under investigation. Figure 1 shows the computed insolation on Summer Solstice at 65N and 65S latitudes, from one million years before present (ybp)  to three million ybp. 

 

Raymo insolation  

Figure 1. Calculated 65°N summer insolation records for NH (21 June) and SH (21 December) (Raymo, et al.).

 

Using a simple ice-climate model, the following ice-sheet histories are computed.

 

Raymo ice sheet histories

Figure 2. NH (blue) and SH (red) modeled ice volumes (Raymo, et al.).

These traces show the modeled advance and retreat of ice sheets (glaciation and deglaciation) in the Northern and Southern Hemispheres.

Putting all this together, Dr. Raymo models the global sea level and corresponding 18O isotope levels.

 

Raymo sea level and d18O

Figure 3. Predicted sea level (solid line) and mean ocean δ18O (dashed line), derived from the ice volume histories in Fig. 2 (Raymo, et al.).

Finally, the predicted mean ocean δ18O is compared with the actual values recovered from ocean sediment cores (2).  

 

Raymo d18O predicted and observed

Figure 4. Comparison of predicted mean ocean δ18O and the LR04 stack (Raymo, et al.).

 

The agreement is pretty good. In particular, this model reproduces the puzzling 41,000-year (41 ky) frequency that dominates the measured δ18O record.

 

raymo spectra

Figure 5. Spectra of the LR04 stack, the paleomagnetically dated δ18O stack of Huybers, the paleomagnetically dated benthic δ18O record, 21 June summer insolation at 65°N, and NH model output from Fig. 2.

 

Insolation drives Earth's climate system*. You might imagine that the climate system responds to a signal like Figure 1 in a complex way. How many parameters does it take to describe that response? How many variables dominate the climate system?

Because the climate system is enormously complex, it's easy to think that the number of parameters required to describe its behavior is large. But one of the interesting results from nonlinear dynamics ("chaos theory") is that complex dynamics can arise from simple systems (and vice versa). There's something about the δ18O trace that makes me think that the number of parameters is small. How to test this idea? Constructing a phase space portrait can help.

We have a one-dimensional set of time series data that comprises a "slice" of the total system dynamics (δ18O measurements from ocean sediment cores). It's possible to recover the dynamics of the remaining dimensions by "embedding" the one-dimensional signal in a two-dimensional space, a three-dimensional space, and successively higher spaces. In principle, this is done by plotting the signal against its higher moments, i.e., against its first derivative, its second derivative, and so on. When we don't have direct measurements of these quantities, we can approximate them by plotting the signal against itself, with a time delay (for a 2D reconstruction) as follows.

x-axis: f(t)

y-axis: f(t-τ)

where f(t) is the signal, and τ is the time delay, usually expressed in number of samples.

This is the method of delays, and the resulting phase space reconstruction is sometimes called a pseudo-phase portrait.

For example, the Van der Pol oscillator can produce the following time series.

 

Figure 6. Signal from the Van der Pol oscillator viewed in the time domain (Van der Pol Oscillator).

 

When a one-dimensional Van der Pol signal is embedded in a two-dimensional phase space, the following phase portrait is the result.

 

Figure 7. Phase portrait of the Van der Pol oscillator (Phase Space).

 

A three-dimensional embedding uses a delay of for the third dimension.

z-axis: f(t-2τ) 

The following 3D phase portrait is reconstructed from electroencephalogram (EEG) data (3). The top trace shows the time series data, and the bottom diagram shows the corresponding phase portrait.

 

Michel Le Van Quyen phase space

Figure 8. Three-dimensional phase space reconstruction of neurological data (Michel Le Van Quyen).

 

Now we can examine the phase portraits of climate data I promised so long ago. Here are the phase portraits of the computed Northern Hemisphere (NH) insolation from Figure 1. The two-dimensional embedding is shown in the left frame, and the three-dimensional embedding is shown in the right frame.

 

NH insolation phase portraits

Figure 9. Phase portraits of the computed NH insolation from Fig. 1.

 

The value of τ = 32 samples is chosen by trial and error. I want the trace to intersect itself as seldom as possible. Because the 2D embedding looks "squashed" I assume that we need a 3D embedding to visualize the dynamics effectively. Not shown here is the rotation animation I've applied to the 3D phase portrait that lets me see it from different angles. Also, I've applied a cubic spline interpolation to the original data to make the phase portraits smoother. One interesting feature revealed by the 3D phase portrait is the presence of discrete bundles of orbits. This suggests that there is an attractor at work.

Here are the phase portraits of the computed global sea level, as a function of insolation and the simple ice-climate model used by Dr. Raymo.

 

global sea level phase portraits

Figure 10. Phase portraits of the computed global sea level Fig. 3.

 

Here's the same portrait, with the 3D embedding viewed from another angle.

 

global sea level phase portraits2  

Figure 11. Phase portraits of the computed global sea level from Fig. 3.

 

What's interesting about the 3D portrait is the introduction of a funnel shape to the dynamics.

Here are the portraits for the modeled mean ocean δ18O from Figure 3.

 

model d18o phase portraits

Figure 12. Phase portraits of the modeled δ18O from Fig. 3.

 

Banding in the phase portrait, similar to that in the insolation portrait (Figure 9), is still visible.

Finally, here's the phase portrait for the actual δ18O measurements from ocean sediment cores.

 

LR04 stack phase portraits

Figure 13. Phase portraits of the measured δ18O from Fig. 4. Original data have an applied cubic spline interpolation to smooth the portrait.

 

Okay, it's hard to tell much of anything from these. Banding isn't really apparent, and the overall portrait is a tangled mess. The only obvious similarity to the portraits in Figure 12 is the presence of the "outlier" orbits. We'll need a few more tools to tease anything out of these portraits. Future work includes:

  • Visualizing Poincaré sections, which show slices of that tangle and may reveal an attractor pattern;
  • Visualizing the phase-space flow, which involves displaying little arrows that follow the orbits around the phase portrait;
  • Reworking the PhaseSpaceControl to use a Trackport3D, which lets the user tumble and zoom the portrait with the mouse.

I'll keep you posted as I implement these features. 

Update: Dr. Raymo kindly pointed me to the work of Barry Saltzman, who pursued the question of nonlinear (chaotic) dynamics in climate models. She provided a couple of citations, and after a quick trip to the Fish/Oceans library at the University of Washington, I have a hardcopy of Dr. Saltzman's 1994 paper (4). 

Dr. Saltzman proposes that for the last five million years, the climate system can be modeled with three slow-response variables: global ice mass, CO2, and ocean temperature. This is an exciting confirmation of my intuition, and I'll blog as I investigate further.

Another update: On to Part 2.

---

* Volcanism and heat diffusing from the molten interior contribute a very small quantity of energy to Earth's surface, around two orders of magnitude less than the sun's energy. This contribution is considered to be negligible.

[1] Plio-Pleistocene Ice Volume, Antarctic Climate, and the Global δ18O Record, Raymo, et al. [2006] Science.

[2] Lisiecki, L. E., and M. E. Raymo (2005), A Pliocene-Pleistocene stack of 57 globally distributed benthic δ18O records, Paleoceanography, 20, PA1003, doi:10.1029/2004PA001071.

[3] Disentangling the dynamic core: a research program for a neurodynamics at the large-scale, Michel Le Van Quyen, Biol. Res. v.36 n.1, Santiago 2003.

[4] Late Pleistocene Climatic Trajectory in the Phase Space of Global Ice, Ocean State, and CO2: Observations and Theory,  Barry Saltzman and Mikhail Verbitsky,

Paleoceanography, 9(6), pp 767–779, 1994.  

Posted by jgalasyn | 1 Comments

WPF Designer: Changes and Fixes in VS2008 SP1 Beta

Here's the definitive list:

List of changes and fixed issues for Visual Studio 2008 Service Pack 1 Beta for Windows Presentation Foundation Designer

New features

  • The Properties window now contains the Events tab. The Events tab lets you create events, assign events, and review events.
  • The Properties window now includes a category sort option and an alphabetical sort option to allow for faster property location.
  • Code changes have been made to the XAML Refactor/Rename definition and to the Go to definition. These changes allow XAML rename operations to occur automatically. Additionally, you can navigate the XAML definition by pressing F12.
  • You can now drag controls or create controls from the toolbox in XAML view or in Design view. You can do this even if you use a split view configuration.
  • Snaplines are now implemented for control margins. This lets the designer control a fixed distance from other controls, from container edges, or from gridlines.
  • Tab controls now support TabItem activation and TabItem design. To do this, click the tab that you want to design.
  • The Expander control now expands conditionally based on what is selected. You can design the contents of the Expander control at design time with affecting the IsExpanded attribute of the runtime.
  • Many stability improvements have been added to Visual Studio 2008 SP1. These include improvements to document loading in the designer and to error reporting. Because of these improvements, you will be able to load more documents in the designer.
Posted by jgalasyn | 0 Comments

Visual Studio 2008 SP1 Beta is posted

Get it here.

Discuss amongst yourselves at the forum.

Don't miss Guy Burstein's guided tour.

Here's the official word:

Visual Studio 2008

  • With Visual Studio 2008, developers and development organizations have the tools that enable them to be more productive, take advantage of all the latest platform advances on Windows, Office and the Web, and collaborate more effectively throughout the software lifecycle.
  • Visual Studio 2008 offers more than 250 new features and improvements to existing features, providing developers of all skills sets – from the hobbyist to the small development shop to enterprise development organizations – the tools they need to build great applications.
  • Microsoft is committed to helping developers be successful and provides community resources, reference material, software, add-ins, and more to guide construction of Software+Services applications, data-driven solutions, and compelling user experiences.
  • Visual Studio 2008 SP1 beta introduces improvements and new functionality in several areas including:
    • Full support for SQL Server 2008.
    • Improved functionality and performance in the WPF designers.
    • Additional components and tools for Visual Basic & Visual C++ including an MFC-based Office 2007 Ribbon and various stability improvements.
    • Richer JavaScript features.
    • Improved Web development and site deployment.
    • Performance improvements for the IDE.
    • Improvements to TFS to respond to customer feedback on version control usability and performance, improved email integration with work item tracking.  In addition, TFS now provides full support for hosting on SQL 2008 and Windows Server 2008.

.NET Framework 3.5

  • With the .NET Framework 3.5 Microsoft is extending the capabilities in the framework with new support for Internet protocols, peer-to-peer communication, device programmability, and data handling. The .NET Framework provides a single, common programming model supporting the broadest set of applications.
  • Microsoft is committed to delivering enhanced capabilities and increased productivity for developers in the .NET Framework 3.5.
  • Expanded and improved offerings in the .NET Framework and tooling support in Visual Studio 2008 gives developers enhanced capabilities to build S+S, SOA and Web 2.0 applications.
  • The .NET Framework 3.5 SP1 beta introduces improvements and new functionality in several areas including:
    • More controls, streamlined setup, improved start-up performance, powerful new graphics features for client development and rich data scaffolding, and improved AJAX support.
    • Introduces the ADO.NET Entity Framework and ADO.NET Data Services, simplifying data access code in applications by providing an extensible, conceptual model for data from any data source and enabling this model to closely reflect business requirements.
Posted by jgalasyn | 0 Comments
Filed under: , ,
More Posts Next page »
 
Page view tracker