Development Patterns: 3 Layers Web Software Development

Hi,

How is it going? =)

Today I'll begin to discuss with all you about Development Patterns. This is very important to all programmers.The first one is 3-Layers. So, go on..

Development in 3 Layers in Computing means to separate the system logically in 3 independents layers. They are:

-> Data Access Layer
-> Business Logic Layer
-> User Interface

Data Access Layer is responsible to communicate with data physical storage and to abstract them in a structure to make it able to be used by others layers.

Business Logic Layer contains the intelligent area from the system. It manipulates all the information provided from the Data Access Layer, it makes and invokes actions and provide information to be shown in the layer above.

User Interface is the layer that shows the informations to the users e receive their actions.

Object-Oriented Programming makes it ables to be made easily and this development type is becoming stronger because OO owns all the sources needed by its.

The advantage of this type of development is that, with layer independence, changes can be made without big impacts in all the system. You can change all your data storage, do migration between different Data Bases, provide data via WebServices, etc... without change any other part of others layers. Or add others functionalities in your system without stay worried with the Data Access, even though change all your interface, ... without stay worried about any other layer.

But, nothing is perfect, this development type also brings some disadvantages. Object transition between layers is not the better way to earn performance and to work with development in different layers can become hard. But, there are a lot of ways to reduce both.

Web Development Technologies delayed to give needed support to this type of development. But, the new age of development looks like to have borned to this.

All FrameWork Asp.Net Languages (C#, VB.net, J#) were developed (or adapted) to Object-Oriented Development. And Jsp (Java Server Pages) inherits OO from Java, the first one of the OO modern languages. Php also is in this wave with the version 5, with a great Objected-Oriented Support.

In my view, Web Applications have a lot of advantages to earn with this type of development. More the Desktop Application.

Next post we will discuss about MVC Development Pattern.

See Yah'' =)

Sony PSP vs. Nintendo DS

Processing Power
This one is obviously in the PSP's favor. While the Nintendo DS has a very capable 3D chip, able to render the likes of Super Mario 64, it's no contest that the PSP has more raw power than the DS. Even the launch games (which didn't exactly have a ton of time to be developed) approach the graphical abilities of the PlayStation 2. Comparing a PS2 to the N64 is like night and day, and that's pretty much the same comparison that can be made here. Really, this one is no contest.


Winner: PSP

---

Screen(s)
With the pure processing power being the first, the screens of the two systems are really the second major battlefield that the two systems are waging battle on. The PSP's screen is no-doubt a beautiful thing, though the Nintendo DS has two of them, one of them being a touch screen. So which setup is better?

It's hard to say. Each display type has its pros and cons. The PSP's screen is bright, vibrant and exceptionally clear. The viewing angle is magnificent; you can view the on-screen action from most any angle and still see a very good image. It also touts a widescreen aspect ratio and a relatively large size.

The PSP's screen isn't perfect, however. Its refresh rate isn't the greatest thing ever, rather it's far from it. While a screen full of motion can fool the eye plenty well enough, objects that move quickly against a slower or still background can bring the refresh rate problems to the forefront. Reds are especially susceptible to this. It's also a pain to keep clean, as is the system as a whole.

The Nintendo DS' strengths are in its dual-screen setup and its bottom touch screen. The ability to control on-screen actions with the touch of a stylus makes it possible for developers to create entirely different games than what's possible on other systems with conventional control systems. As well, having two separate view areas means that some of the action, information or what have you can be pushed off to the second view, making for a potentially cleaner interactive view.

When compared to the PSP, however, the Nintendo DS' screen quality falls short. The viewing angles aren't nearly as nice, and the colors and overall clarity just don't compare. It does sport a better refresh rate though, saving it from some of the blurring problems that the PSP suffers from.

So again, which setup is better? Really, this one is too close to call for either side. The PSP really wins out in quality, but the DS wins in screen interactivity and the potential for unique designs.

Winner: Tie

---

Battery Life
When it comes down to battery life, the Nintendo DS is the clear winner here. The PSP needs plenty of juice to feed all that power and it drinks it a-plenty. The interesting part is that it's almost entirely variable; a game that pushes the system to its max and uses the UMD drive plenty will kill the battery faster than you can charge it. On the other hand, a simple puzzle game that rarely needs to access the drive would likely let the system run about as long as the same game on the Nintendo DS. But since most the games on the system will skew more towards the graphically-intensive variety, this one goes to the Nintendo DS.

Winner: Nintendo DS

---

Controls
Both systems feature the same main controller layout with a D-Pad, four main action buttons on the face of the unit and two triggers. The main differential is the PSP's analog stick vs. the DS' touch screen.

This is another hard one to call as this one obviously comes down to titles on an individual basis. If we were talking about cross-platform type games, like sports games or the like, then the PSP's analog stick is the clear winner; it just works much better as a generalized analog input device. But the DS' strength is in its ability to allow for unique input schemes, like in such games as Wario Ware Touched!

Concerning the other controls, each system has its strengths. The DS has the better set of triggers. The PSP's triggers are sort of clunky and not all that comfortable, while the DS' triggers are springier and generally more comfortable to use. The PSP features the better face buttons as they're bigger and feel more like a regular controller. The DS' face buttons are rather small. Deciding the better D-Pad is sort of a toss-up as it probably comes down to a matter of taste. Both are good, however.

When it comes down to it, the PSP features a much more standardized input system with its analog stick, though the DS allows for much greater creative design with its touch screen. Really, it's a matter of the select game at hand that decides which system has the better controls, and though the PSP will win for most mass-market games, the Nintendo DS has plenty of room for innovative control methods. But when it comes down to it, the PSP is much better suited for 99% of the games on the market.

Winner: PSP

---

Load Times
Like the battery life, the Nintendo DS has the huge advantage when it comes to load times. Being that the DS uses EEPROM cartridges, which are nearly identical to that of a memory card, it's able to load data much, much faster than the PSP's UMD drive. Gamers who are used to immediately jumping into a portable game may not feel at home with the PSP's load times, which like its hardware, very much mirror that of its PS2 counterpart.

Winner: Nintendo DS

Portability
By portability, we're referring to how easy it is to throw the system into your pocket or backpack and stroll off without worry of damage to the system. In this regard, the Nintendo DS' flip design takes the cake. When closed, all of the DS' important parts are enclosed and safe from bruises, bumps and scratches. The PSP, on the other hand, requires that you slip it into some sort of case in order to protect its screen. No matter how good the screen looks out of the box, it'll look like crap very quickly if you don't take care of it to protect it from scratches.

Size-wise, the difference between the two systems is rather negligible. When closed, the DS is a little taller and wider than the PSP, though the PSP is a little longer. In any direction the difference is no more than about an inch, which given the size of the systems isn't very much. Either system will fit in your pocket, though not very comfortably unless it's a very large pocket. Weight is also a non-issue with either system.

When it comes down to it, the DS is more portable in and of itself. The PSP requires some sort of casing, and even though the PSP Value Pack comes with a pretty nice slip cloth, it won't protect it a whole lot from things slamming up against it. The DS seems like it would naturally hold up better to bumps and bruises. Granted, you can outfit the PSP with a nice metal case that should protect it from anything, but the same could be said about practically any device.

Winner: Nintendo DS

---

Media
The Nintendo DS uses Game Cards, capable of storing up to 128MB of data as of now, though larger chips could theoretically be used to increase that size at some point in the future. Cost and whatnot obviously plays a factor there. The DS is also capable of playing Game Boy Advance games, so that's worth mentioning here.

The PSP uses UMD discs, capable of holding up to 1.8GB of data. While it can't write to those discs for saves, the PSP also makes use of Memory Stick Duos for saves and media. Memory Stick Duo media is currently available in 1GB versions with 2GB versions on the very near horizon.

Really, the only thing in the DS' favor when it comes to media is its faster read speeds, which as mentioned earlier is a pretty big difference. However, the PSP is capable of much more with its media ports. With its UMD discs, games can be exponentially larger than those on the DS. Large games with tons of art may be plentiful on the system, as could cutscenes. Using a Memory Stick Duo, gamers can easily trade save files either by swapping cards or copying their saves to their PCs via the PSP's USB port. Add in the ability to copy audio and movies to the system and you have a much more robust media setup.

Winner: PSP

---

Wireless
The fully-fleshed-out capabilities of both systems really have yet to be seen. It was recently announced at this year's Game Developer's Conference that the Nintendo DS will soon have full online support for multiplayer via its wireless connection, putting it on par with the PSP's wireless capabilities. The PSP has supported games on the shelf as of this writing, while the DS does not. Still, they're on the way and at this point it's hard to say which system will make better use of it. And actually, it'll almost certainly be up to the developer on that end, so this is really a tie.

Winner: Tie

---

Final Word
If you add up the tallies, it comes out to Nintendo DS: 3, PSP: 3, Tie: 2, or an overall tie. But that doesn't really tell the whole story. If you look at the category winners, the PSP takes the system power, control and media categories while the Nintendo DS takes battery life, portability and load times.

So in theory, the Nintendo DS is a better portable system but the PSP is the better all-around system. This seems like a fair enough assessment and the final word we'll stick with.

.NET Framework 3.0

Microsoft’s .NET Framework 3.0 (formerly codenamed “WinFX”), is the new managed code programming model for Windows. It combines the power of the .NET Framework 2.0 with four new technologies: Windows Presentation Foundation (WPF), Windows Communication Foundation (WCF), Windows Workflow Foundation (WF), and Windows CardSpace™. Use the .NET Framework 3.0 to build applications that have visually compelling user experiences, seamless communication across technology boundaries, the ability to support a wide range of business processes, and an easier way to manage your personal information online.

You can download it at: http://baixaki.ig.com.br/download/Microsoft-NET-Framework-3-0.htm

See more at: http://msdn2.microsoft.com/

Choosing between C# and VB.NET

The .NET Framework supports a variety of programming languages, including Microsoft?s much heralded C#. Huw Collingbourne considers whether Visual Basic is still as sharp as the competition.

What you can do with c#.net:


In the past, different programming languages tended to do things in their own way. Programmers using C++ would, in all probability, make use of the types and routines provided by the Microsoft Foundation Classes (MFC) libraries; Visual Basic had its own built-in types and routines; non-Microsoft languages such as Delphi and Java used yet other class libraries, each of which was incompatible with each other.
With the advent of .NET that has changed. No matter which programming language you use, you will have access to the same rich collection of classes and functions provided by the .NET Framework. Indeed, it is even possible to write classes in one language and derive descendant classes from them in another language. Your source code is not compiled directly into a machine code executable. Instead it is translated into Microsoft Intermediate Language (MSIL). This intermediate language is only converted into machine code when the program is run by the .NET Common Language Runtime (CLR).
In effect, the .NET CLR understands only one language: MSIL. This means that it really doesn’t matter which language your programs are written in. Whether they were written in C#, J#, VB, Delphi or some other .NET language, they will all end up as MSIL.
Given the fact that all .NET programming languages have access to the same class library, are translated to the same intermediate language and are executed by the same runtime system, you may wonder what, if anything, there is to choose between them. In this article, I shall be taking a close look at Microsoft’s two principal .NET languages, C# and VB.NET, in an attempt to answer this question.

Choosing between C# and Visual Basic
As far as the .NET Framework is concerned, all programming languages are pretty much equal. In the past, you may have evaluated languages on the basis of their compilation and execution efficiency or their editing, design and debugging tools. Most of these considerations are irrelevant when programming for .NET. Languages such as C#, VB.NET and others can, in principle, access the same classes and output the same MSIL code. When hosted by Visual Studio .NET, they even share the same development environment.
The really important differences between the languages are not to be found in their interaction with the runtime system but in the support they offer to the programmer. In short, the syntax, the structure and the clarity of the languages are paramount.
You only have to glance at some C# and VB.NET code to see some of the obvious differences. On the whole, C# is much terser than VB.NET. To take a simple example, consider the way in which the two languages delimit blocks of code. In common with other C-like languages such as C++ and Java, C# uses curly brace delimiters. VB.NET, by contrast, uses various keywords such as End If, End Sub and Next to terminate specific code blocks.
Some people would argue that the more verbose syntax of VB.NET makes the code clearer (more ‘self documenting’). On the other hand, it would equally well be argued that C# has the virtue of consistency, since curly braces are used to delimit everything and the built-in bracket matching tool makes it easy to find the braces at the start and end of each code block. Ultimately, this is a matter of personal preference which is likely to depend on your previous programming experience.
While it is generally true to characterise C# as the terser language, this is not invariably the case. When you need to read or write multiple properties of a single object, VB.NET provides the very useful with keyword. This lets you enter the object variable just once rather than repeatedly. This can often make VB.NET considerably less verbose than C#, as you can see in this example:

’ Set TabPage properties in VB.NET
With TabControl1.TabPages(0)
.BackColor = Color.Red
.BorderStyle = BorderStyle.Fixed3D
.ToolTipText = "Click Me!"
.Text = "Hello world"
End With

// Set TabPage properties in C#
tabControl1.TabPages[0].BackColor = Color.Red;
tabControl1.TabPages[0].BorderStyle = BorderStyle.Fixed3D;
tabControl1.TabPages[0].ToolTipText = "Click Me!";
tabControl1.TabPages[0].Text = "Hello world";

For programmers with no previous experience of a C-like language, VB.NET code will, in most cases, be easier to understand than the C# equivalent. Take the example of a simple for loop. You could read this VB.NET version aloud and understand what it does:

For i As Integer = 0 To 7
TabControl1.TabPages(i).Text = "Tab: " + i.ToString()
Next i

The same cannot be said of its C# equivalent:

for(int i = 0;i < style="font-weight: bold;"> tabControl1.TabPages[i].Text = "Tab: " + i;
}

Incidentally, there are two interesting things to note in the code fragments shown above. First, experienced VB programmers may be surprised to see the declaration of i As Integer in the For loop. In previous versions of VB, the counter variable in a For loop had to be pre-declared. The other thing to note is that C# automatically converts the integer variable, i , to a string when it is concatenated using the + operator. VB.NET does not permit this. Instead it requires the variable to be explicitly converted using the ToString() method.

Smooth Operators
There are several non-intuitive or ambiguous features which C# has inherited from the C language. To take a simple example, C# allows programmers to increment or decrement the values of a variable by placing two plus ( ++ ) or minus ( -- ) characters either before or after the variable. The resulting value can then be assigned to some other variable. However, the effect of the assignment varies according to the position of the increment operators. If placed before the variable, the increment is done before the value is assigned. If placed after the variable, the value is assigned before the increment is done. Used carelessly, this can result in subtle bugs. The VB.NET syntax does not allow such ambiguity.
On the other hand, VB.NET has acquired some C-style operators which can be used for brevity. The += and -= operators, for instance, allow you to increment or decrement the value of a variable without having to repeat the variable name on the right-hand side of the assignment:

x += y ’ this is the same as x = x + y

Other distinguishing features of the VB.NET and C# languages include the case sensitivity of C#. In VB.NET, a variable named MYVAR can also be written as myvar. In C#, these would be treated as two different variables. There are, of course, numerous syntactical differences ranging from the declaration of variables ( Dim VariableName As TypeName in VB.NET, TypeName VariableName; in C#) to the way in which statements are terminated (typically the end of a line in VB.NET and a semi-colon in C#).

Better Safe Than Sorry?
More significantly, C# gives programmers the option of using pointers. Pointers are variables which refer or ‘point’ to specific locations in memory. They are so widely used in C and C++ that many programmers may find it difficult to conceive of programming without them.
The trouble with pointers is that they are inherently unsafe. They make it easy to corrupt memory, overwrite data and crash your applications. C# discourages the use of pointers but does permit their use within blocks of code marked with the unsafe directive.
Code marked with the unsafe directive is ‘unmanaged’. This means that it is run as native machine code without benefiting from the services of the CLR. The use of pointers may be useful for certain special programming tasks that require the direct manipulation of memory or interaction with COM. In most cases, however, the .NET Framework provides all the services your program requires without having to resort to the hazards of unmanaged code. VB.NET is more restrictive than C# in this respect. It does not permit the use of unsafe code under any circumstances.
Even so, it is not quite true to say that pointers can never be used. VB.NET provides access to pointers using the IntPtr type. This allows a limited range of pointer operations. For example, an IntPtr variable can be used to store a handle to a file or a window.
If you prefer to program in VB.NET but have an occasional need to use pointers, you can, of course, add a C# or even a C++ project to your solution in order to do all the ‘dirty work’.

Developer Support
Aside from the features of the languages themselves, there are also several significant differences in the way in which they are supported by the Visual Studio .NET environment. The code editor provides more automatic formatting and IntelliSense code-completion for VB.NET than for C#. For example, to create a property in VB.NET you need only enter the keyword property and a name such as MyProp. When you press the Enter key, the editor generates all of the following code:

Property MyProp()
Get
End Get
Set(ByVal Value)
End Set
End Property

In C# you would have to enter all the equivalent code for a property by hand.
The editor supplies many other types of automatic formatting for VB.NET. For example, it adjusts the capitalisation of keywords for consistency and it optionally reformats code by logically aligning statements, adding missing end quotes to strings, supplying parentheses to function calls and so on. The automatic formatting options available to C# are far less complete.

The Visual Studio editor provides a number of automatic code formatting and completion options specifically for VB.NET. These can be disabled if you don’t like them.

Making the choice
In summary, when evaluating programming languages for .NET, the choice between C# and VB.NET is largely a matter of personal preference. In the past, VB may have been looked down upon by some developers who considered it to be inherently less powerful than other general purpose languages. But VB.NET is altogether a different beast from VB6. It is every bit as powerful as C#, it has full access to the .NET Framework and its compiled applications should generally be just as fast and efficient as similar applications written in C#.
The only major difference between the two languages is that C# can break out of the ‘managed’ world of .NET to support unsafe code should this be required. However unsafe code is, as its name suggests, inherently hazardous and you may feel that it is a good thing to avoid using it. Explicit use of pointers is seldom required when programming .NET. If you really feel that you cannot do without pointers, then C# would be a good choice of language. If you are happy to work within the managed world of .NET, then C# or VB.NET would be equally suitable for your purposes.
Of course, there are other .NET languages available too. At first sight, C++ might seem the most attractive choice for programmers with previous experience of that language. You need to be aware, however, that the .NET version of C++ is best used for manipulating unmanaged memory. In most cases, C# would be a better choice of .NET language for a programmer with C++ experience. Unlike C++, the C# language was specifically designed for the .NET Framework. It benefits from a simple syntax, garbage collection and type safety to eliminate many potential bugs.
For Java programmers, the J# language provides a Java-style alternative to C#. It offers the easiest migration path for projects developed using Microsoft’s Visual J++. However, bear in mind that the syntax of C# is also very similar to that of Java. Moreover, both Java and C# provide garbage collection to reclaim unused memory, they both avoid pointers by default and implement a simplified form of single-descent object orientation. Unless you have a particular reason for selecting J#, therefore, the C# language should generally be preferred.

source: http://www.dnjonline.com

Ubuntu Linux Vs. Windows Vista: The Battle For Your Desktop

Is Design the most important thing in a OS? There are some people that look like to think in this way... Let´s see this issue, to describe...

Is Linux finally ready to take on Windows as a desktop OS?



The prevailing wisdom about Linux on the desktop runs something like this: "I'll believe Linux is ready for the desktop as soon as you can give me a Linux distribution that even my grandmother can run."

For some time, the folks at Ubuntu have been trying their best to make Granny -- and most everyone else -- happy. They've attempted to build a Linux distribution that's easy to install, use, configure, and maintain -- one that's at least as easy as Windows, and whenever possible, even easier. As a result, Ubuntu is one of the Linux distributions that has been most directly touted as an alternative to Windows.

In this feature, I'm going to compare the newly-released Ubuntu 7.04 (codenamed "Feisty Fawn") with Microsoft Windows Vista in a number of categories. To keep the playing field as level as possible, I'm looking wherever I can at applications -- not just in the sense of "programs," but in the sense of what the average user is going to do with the OS in a workday. Sometimes the differences between the two OSes are profound, but sometimes the playing field levels itself -- OpenOffice.org, for instance, is installed by default in Ubuntu, but adding it to Vista isn't terribly difficult.

I tried to stick whenever possible with preinstalled software, although this rule sometimes had to be bent a little -- for instance, to see what backup solutions were available for Ubuntu through its own software catalog.

Also, while I was tempted to compare Vista's Aero interface to the Beryl window manager (which has a similar palette of visual effects), I decided that pretty graphics, while nice, had more to do with personal preference than efficiency. In addition, Beryl isn't installed by default in Ubuntu, and Aero isn't available on all PCs.

In each case, I've tried to look at practical benefits rather than theoretical ones -- what works, what doesn't, and what you have to do to get certain things done. I should also note that, despite being a big fan of Vista, I've tried to keep my enthusiasm for it from overriding my judgment. Everyone needs something different, and not everyone needs (or wants) Vista -- or Ubuntu -- so I've done my best to keep my mind, and my eyes, wide open.

See the complete issue at: http://www.informationweek.com/news/showArticle.jhtml?articleID=199201179&pgno=1&queryText=

.NET vs. Java: No Easy Answers

Hi, folks!

Here we go again! Which one do you choose? Java or .Net ? It's difficult to choose, isn't it? Here, you can see an article from ftponline.com , this is very interesting!

See yah''

.NET and Java are both here to stay. How do you choose which is right for you?

At Gartner we believe two platforms will dominate e-business-oriented application development efforts over the next five years: Microsoft and Java. Today, this certainly isn't a rocket science prediction and it doesn't take a crystal ball to see that it's already happened to a large extent. To Gartner's credit, this was a more compelling prediction two years ago when Java's future was much less assured and .NET was still a whispered code name inside Microsoft's R&D labs.

Today the subject of Microsoft vs. Java is the most popular inquiry subject I receive from developers and commercial software vendors. It seems that virtually every IT development organization has two contingents locked in a constant battle to push their favorite platform onto the other. Not to mention the fringe factor that believes Linux and PHP will dominate the world, insisting that we all bow down to the great penguin.

What is surprising to many is that we don't believe there will be a clear and decisive winner in this market-share battle. Unfortunately, no matter which side of the fence you fall on, this is probably precisely what you don't want to hear. Instead, most of us prefer clear-cut victory or defeat—nobody likes a tie. However, both platforms are here to stay for awhile, so this month I'll discuss the competitive relationship between them and strategies for choosing one approach over the other for your organization's development efforts.

Between the two platforms, both Microsoft and Java solutions will collectively make up 80 percent or more of new application development projects by 2005. However, neither will have a substantial market lead over the other and they will remain closely locked and overlapped in many markets. Despite this close competition, there are some emerging trends indicating where the platforms are likely to be adopted within corporate and commercial development groups.

Java Tends to Flow From the Top Down
By their very nature, large IT enterprises must often manage highly heterogeneous data center environments; the average Global 2000 IT infrastructure typically consists of a wide variety of hardware and software platforms (such as MVS, OS/400, Unix, and Windows). These organizations are attracted to Java because of its multivendor and multiplatform features. For instance, if an organization has a long-term relationship with a company such as IBM, Oracle, or Sun, it will likely be attracted to (or coerced into) a Java-centric development strategy. Likewise, if a company has a large mixture of hardware and operating-system platforms, it's likely to look to Java for its potential to deploy an application on Windows 2000 today with the option of migrating it to a mainframe or large Unix platform in the future. In these cases, the promise of portable Java technology across these platforms is highly attractive.

Of course, Java's "write once, run anywhere" ideal is just that—an ideal that falls short of its ultimate goal. To the credit of Sun and its closest partners, they've managed to keep the platform relatively unified—no small feat considering the competitive relationships among them. I receive consistent feedback from commercial Java vendors and in-house developers that indicates most are achieving approximately 80 percent code compatibly when they move from one platform to another. This is by no means perfect, but it is substantially better than anything else on the market today.

Java technology tends to take center stage when companies address technology needs in "big" strategic terms such as best-of-breed vendor selection, long-term architectural compliance, legacy extension, and interoperability.

Microsoft Tends to Build From the Bottom Up
Alternatively, smaller enterprises and small independent groups in larger enterprises tend to lean more strongly toward Microsoft development technologies as their focal points. These groups are better able to consolidate their data centers around a single platform and are consequently better able to commit to Microsoft's technology exclusively (see Figure 1).

Because of the low cost of entry and a strong focus on rapid application development (RAD), Microsoft's platform tends to take center stage when a quick time to market dominates the decision. These organizations are under strong pressure to deliver large numbers of small applications and rely on technology such Visual Basic to deliver them quickly with limited resources.

Figure 1 Make Your Choice

In each release of its operating system, middleware, and development tools, Microsoft continues to dispel the myth that its software doesn't scale. In fact, development teams today are achieving remarkable complexity and scalability with Microsoft and Wintel-based solutions. Yet the company hasn't achieved much respect as an "enterprise" software vendor. Instead, it has slowly marched up the enterprise from its origins as the PC DOS provider, to simple departmental client/server applications, and now to larger scale Internet and e-business-centric solutions.

It is true, however, that it often does take more effort to scale Microsoft-based solutions for very large deployments (typically exceeding several hundred concurrent users) than it does to scale a similar Java application. However, this isn't necessarily a reflection of the software architecture, but rather the available deployment options.

Today, Microsoft-based solutions are limited nearly entirely to Wintel class platforms. In other words, when you choose .NET you also implicitly choose your operating system, middleware, and hardware deployment platform. Alternatively, Java is a software platform largely independent of the underlying middleware and operating system. You choose Java first, then a J2EE application server (such as WebLogic or WebSphere), then an operating system (Windows 2000, Solaris, Linux, and so on). These "choices" can be either a blessing or a curse—with Java, you're allowed to choose but likewise you are also forced to choose.

Ironically, the .NET Framework can potentially be ported to other platforms much more easily than the older Win32/COM technologies. In fact, Microsoft has submitted a subset of the framework to the European Computer Manufacturer's Association (ECMA) open standards committee to be ratified as a true portable and open standard. However, to date, this effort can only be described as half hearted.

The subset of the .NET Framework submitted to ECMA is just enough to build a C# language compiler and its supporting runtime. The problem, unfortunately, is that this technology isn't particularly interesting for real-world solutions because it's completely insufficient to build robust, portable .NET applications that you could potentially deploy across platforms.

Microsoft remains quiet regarding its intentions to submit additional elements of the .NET Framework to ECMA in the future, but don't hold your breath for it to happen anytime soon. On one hand, the company knows that to be fully competitive with vendors such as IBM and be taken seriously as an enterprise software vendor, it must support the same breadth of features as its closest competitor. On the other hand, it also knows that the company's bread and butter remains tied strongly to the sale of its operating systems and its ability to lock customers into a one-stop-shop relationship. I'll cover the details and possibilities regarding .NET beyond Windows in a future column, but you should assume that .NET will remain overwhelmingly Windows-centric for at least the next three years.

Choose Both
Despite any attempts to select either platform as a "strategic" de facto choice, virtually all large development organizations will ultimately have both. This is particularly true for companies that tend to distribute the responsibility for application development among their business units—each unit will generally choose the tools they like the best. It's entirely unrealistic to assume a large national or multinational company will have all Java or all Microsoft technology. For that matter, legacy platforms such as Cobol will also remain entrenched for many years to come.

In these cases the "us vs. them" battle must be tempered with a higher-level integration strategy. Although there are no easy answers to this problem, technology such as Web services standards are beginning to emerge and will allow better integration and interoperability between the platforms in the future.

Ultimately, larger development organizations will be under greater pressure to support both. Smaller organizations that tend to be more resource-constrained should take a more aggressive stance to choose one platform as their nearly exclusive standard. Overall, .NET will be the overwhelming choice for these developers. Moreover, as it matures over next couple of years, we should expect .NET-based solutions to take an increasing role in larger-scale projects.

One of .NET's primary design criteria is its support for multiple programming languages. This is also one of its most important points of distinction with Java; .NET is designed from the ground up to support many types of languages and there are already a dozen or more language compilers available for .NET ranging from Pascal to Perl. No one should take the "in .NET all languages are created equal" story without a healthy dose of skepticism, but the framework's design certainly makes it easier to mix and match languages within a single project.

Java, on the other hand, focuses on a single programming language integrated tightly with the platform. The Microsoft enthusiast might argue that a single language is never the best answer and instead development teams should leverage the right tool for the right job. This person would argue that by supporting Perl, Visual Basic, C++, and so on, .NET enables you to leverage the programming skills your developers have today, without retraining everyone on the team in a new language such as Java. No doubt, there is a compelling truth to this argument.

On the other hand, a Java enthusiast might debate that it's far too expensive and risky for a development team to support so many languages and variants, and that Java offers a consolidated platform that allows IT shops to "train once and write everywhere." Both arguments have compelling points and most developers will find their comfort zone somewhere between these two extremes.

What About Java Inside .NET?
Given that much of .NET's value is tied to its support of multiple programming languages, it would be a tremendous advantage if you could simply treat Java as just another .NET language.

And, in fact, Microsoft has attempted to provide exactly this functionality in its recently announced J# extension to Visual Studio .NET.

J# is essentially a Java language compiler for .NET that generates native Microsoft Intermediate Language (MSIL) code instead of Java byte code. The tool also provides a code syntax translator to convert native Java to J#. Unfortunately, the J# proposition exposes one major limitation in .NET's multilanguage strategy.

First and foremost, Microsoft has already introduced another Java-like language in .NET—it's called C#. Is there really a need for two languages within a platform with nearly identical syntax? Secondly, most truly object-oriented languages are tightly tied to a corresponding class library (Smalltalk, Java, and so on). The .NET Framework contains its own extensive class library that serves as a unifying substructure for the entire platform. If you separate a language from its class library, you effectively remove much of its value. Although J# provides a language syntax, it also forces developers to rewrite all their existing Java applications to the .NET Framework instead of the Java framework. For example, J# won't support Java Server Pages (JSP) but rather .NET's native ASP.NET. This will have a limited appeal to developers with an existing background and expertise in Java development. At worst, J# will cloud and confuse the value of Microsoft's own C# language and at best will serve as a intermediary step along the road to C# for the last half dozen developers hidden somewhere on a deserted island who still use Visual J++.

Both platforms offer choices. Java provides a single language with many deployment choices. .NET supports many programming languages with a single choice of deployment. Both platforms have emerged as de facto standards for next-generation e-business development efforts. .NET will dominate the RAD-oriented solutions while Java will dominate larger-scale "enterprise" projects. Moreover, both platforms will widely overlap in the middle. However, there will be many exceptions to this trend as .NET is increasingly leveraged for larger projects and matures over next few years.

Source: http://www.ftponline.com/

Welcome EveryOne!!!

Hi,

I'm glad you're here seeing my blogger! I'll try to post only interesting posts, lol. =)

Below this, I post a Dundas Charts Briefing. A very interesting component that must be used in Asp.Net. It ables you to make a lot of different charts to your web aplicattion!!!

I would like to know your opinio about that! :)

See yah''

Thyago Falconi

Dundas - Awesome Components to make Charts!!

Why choose Dundas Chart for .NET?

If you need advanced, award winning .NET charts and graphs, then Dundas Chart for .NET is the perfect solution for you.

From the leader in .NET Charting technology, Dundas Chart adds the most advanced, feature rich, visually appealing charts to your ASP.NET and Windows Forms applications.

We've worked hard to come up with a feature set that offers what you ask for, and over several years of continuous enhancements, we feel strongly that we have produced the most advanced Charting Package available.

Some of the key advantages to using Dundas Chart for .NET include:

ASP.NET Development

Creating advanced web charts is easier than ever with Dundas Chart for .NET. With two different editions available for ASP.NET development (ASP.NET Enterprise Edition & ASP.NET Professional Edition) there is one perfectly suited to your requirements

Windows Forms Development

There are two different editions of Dundas Chart specifically designed for Windows Forms Development, and features specific to each edition (Windows Forms Enterprise and Windows Forms Professional Edition)

Different Editions to meet your needs

The Editions of Dundas Chart for .NET (Professional and Enterprise) are designed to meet the different development requirements of organizations in need of our award winning products. To see the differences and to see which meets your needs, click here.

Visual Studio 2005 Features

We've made sure to leverage the new features of Visual Studio 2005 in the latest release of Dundas Chart for .NET. Version 5.0 includes full compatibility to VS2005 as well as some exciting features such as Smart Tags, high level data binding, debugging display, data series visualizer and more. (Professional & Enterprise Editions)

AJAX Implementation

With AJAX in version 5.5, Dundas Chart for .NET has built-in capabilities for you to add zooming, scrolling, highlighting, toolbars, context menus, property dialogs and much more to ASP.NET Charts, all without using postbacks for a fluid user experience.Read AJAX Whitepaper »

User Interface

Dundas Chart for .NET offers User Interface abilities for the ASP.NET Enterprise Edition (Using AJAX Implementations) as well as for the Windows Forms Enterprise Edition. Both editions offer fully customizable User Interface features such as Context Menus, Toolbars and Property Pages, giving your users the ability to customize and interact with Charts.

Dundas Chart & Data Wizard ™

Easily create charts with the look and feel you need and easily bind it to your data with the advanced Chart and Data Wizard ™. Use it to create new or to edit existing charts, and to quicken the learning curve with Dundas Chart for .NET.

Comprehensive list of Chart Types

A huge assortment of different chart types, including all standard (pie, bar, column, etc.) and many advanced (radar, box, range and more).

Animation

Enable charts with Flash and SVG Animation, to add a new level of presentation to your charts (ASP.NET Enterprise only, click here to read the technical whitepaper on Animation)Read Animation Whitepaper »

Scale Breaks

Scale breaks are powerful functionality that allow you to customize your chart so that large differences between the high and low values of the data being plotted does not diminish the readability of your chart. If you have a data spike that makes your charts unreadable, Scale-Breaks can help. Read Scalebreaks Whitepaper »

SmartLabels™

Smart Data Labels allow for less cluttered displays of data points, with a multitude of settings to get just the look you need (ASP.NET Enterprise Only, click here to read the technical whitepaper on Smart Labels) Read SmartLabels ™ Whitepaper »

Advanced data analysis & manipulation

Apply built-in formulas to your data, filter out data points, handle missing or empty data in an elegant manner, group your data points and much more!

True DateTime Support

Dates and times are stored, manipulated and displayed using .NET DateTime values. Unlike other charting products, data can be plotted along the X axis as true DateTime values.

Design-time support that is second-to-none

Almost all properties (including collection properties), can be set at design-time instead of writing run-time code. In addition properties set at design-time are reflected in the chart image displayed in Visual Studio!

Support material that is the best out there

Includes well over 200 interactive sample applications (comes with C# and VB.NET code), and extensive documentation that integrates into your MSDN.

Comprehensive, object-oriented API

Incredible Performance - We encourage you to download an evaluation and see for yourself how it performs.

Image Formats

Render images as .BMP, .JPG, .SVG, .PNG, EMF, and now Flash and Flash and SVG Animation (ASP.NET Enterprise only.)

Advanced end-user interaction, including zooming, scrolling and the display of data using views.