Slashdot Mirror
Visualizing the .NET Framework
eldavojohn writes "If you're a Web developer, you should check out a quick post about the number of types, methods, & fields in the .NET framework. This was done using NDepend. The numbers are quite large — e.g. 39,509 types. The blogger went on to generate tree maps and a dependency matrix."
[b.belong('us') for b in bases if b.owner() == 'you']
.NET and Java are both prime examples of object-oriented programming gone stupid. Their class libraries have become so utterly huge that it becomes damn near impossible for an individual developer to suitably grasp anything more than a small portion of them.
.NET or Java. It's easy to get lost in whether we need a FileInputStream, or whether we should wrap a FileInputReader in a TextInputBuffer, and so forth. Give me fopen() any day.
.NET standard class libraries. Meanwhile, the POSIX API offers just as much flexibility, but is far easier to work with. Not to mention that programs using it are far more efficient.
Although they supposedly give more flexibility, something as essential as reading from and writing to a file becomes a hassle with
OO was supposed to solve the problems of writing applications in languages like C, Pascal and Fortran. All it has done is brought in a new level of complexity that results in monstrosities like the Java and
.NET really is an amazing framework on which to build software. It just needs more OS support and I would use it for programming other than what I do for a living. All those types are there, but they will not be loaded in to memory unless your software needs them.
That's what I first thought of for visualizing .NET.
The goggles, etc.
Hail Eris, full of mischief...
E pluribus sanguinem
For some reason this reminds me of walking into a Starbucks and asking for a cup of coffee. I don't care about choices, levels, integration. I just want a motherfucking cup of coffee!! dammit!!! If this was supposed to oogle the eyes of unix programmers, it just pushed me further away. I'll use my unix languages and cross-compatible frontends like wx or Qt if I need to have it run on Windows, thank you.
I want to see a comparison to PHP with all extensions/modules enabled... I have a feeling PHP will have many, many more.
.NET anyway? This is Slashdot. ;-)
Sadly, that is not a good thing. I love PHP, but it's a mess and desperately needs an overhaul.
(please note: This is my opinion... not out to start a pissing war.)
p.s. - who the hell uses
1980s classmates. Interesting, on the face, but not something I'd like to revisit.
I enjoyed you as youngster dear Bill Gates, but please don't even think about calling me up after all these years because you're down on your luck.
It doesn't suck because it's made by MS or ripped off from something. It sucks because the documentation is piss-poor. And there isn't a single working (i.e. cut-and-paste) example for a single API (someone told me they break them on purpose so that newbies don't cut-paste themselves into security holes without understanding exactly how the thing works, but hell!)
I noticed the same thing when Apple released their Cocoa framework (with over half of help pages saying "TODO: descrition, example"). Some Quicktime documentation is still that way today!
How anyone expects the undocumented API stuff to be useful is beyond me.
Obama likes poor people so much, he wants to make more of them.
Before you impugn Microsoft with your short-sided emotional appeals against the sheer number of classes, use a hint of logic and realize that since MS copied Java shamelessly and ruthlessly (improving on some debacles in the Java classes, such as the crap IO classes that had to be redone from scratch), you'd be blasting Java, KDE, Python, and most any other class library as well.
.NET class library beats them all easily. It is obvious that the designers did their homework and stole from each library what worked well, while dropping what didn't. If they were smart they'd take Java's excellent concurrency constructs such as the BlockingQueue and put them in (they may already have, I don't program much in .NET lately). Most of my beefs with the class library are the fact that it is huge (footprint size), and I don't agree with some of the modeling. But that is minor.
Look, in a class library that purports to help most everyone, there's going to be an awful lot of code. Class library implies that classes are used to organize the abstractions provided by the library. Proper OO design favors designing more types with smaller number of features rather than God-objects that do many things. Fine-grained objects are simpler to unit test and are much easier to reuse. The downside is the propagation of types and the verbosity level of the code generally goes up. But that is a fair trade-off in my opinion, since the most important work on the code happens in the maintenance phase, when someone else can come along and at least get a vague idea of what is going on.
I've used the class libraries in Java, KDE, MFC, and Python, and the
There's a reason Miguel wanted to make this happen on Linux. It is close to making programming fun again, instead of squinting at hyper-abbreviated function names like sprintf and mucking around with idiotic string representations such as C's.
Hallelujah, brother!
What bugs the snot out of me is that a lot of that stuff is documented really well, but only on developers' blogs. What the hell kind of insulting documentation non-strategy is that? And of course, there's no cross-referencing between msdn and "the blogosphere." So you get to churn away at a search engine until you find a blog entry that's kind of addressing what you want to know.
That said, I do like a lot of stuff about C#. Delegates, for example rank high on that list. And C# 3.5 offers some pretty cool new stuff as well. I likey the lambda expressions, inferred typing, and LINQ.
But the documentation does make me cry at night, sometimes. Sometimes.
If you're a Web developer, you should ignore .NET and use something much less bloated.
There, fixed that for you.
It's better to vote for what you want and not get it than to vote for what you don't want and get it.
- E. Debs
http://msdn2.microsoft.com/en-us/library/1k20k614.aspx
.NET knows to check MSDN for stuff. They have TOO much in the way of examples: one for every target .NET language! So you can have a C#, VB.NET, Managed C++, JScript.NET, J#, and XAML examples on some of this stuff.
I googled for ".net convert string to int" and that came up. The official documentation on Microsoft's site. Anyone who knows anything about developing on
You really can't be serious here.
I remember JLG (the fearless leader of BeOS fame) once saying something to the effect that Windows has five billion lines of code in it and that he "loves every single one of those lines." I also seem to recall Bill Gates once saying that IBM liked software to be measured in k-locs, while he debated that it should be measured by what it does. He said something that I don't quite remember, but the jist was, "why would we do something in thousands of lines of code if it could be done in just a few?" How ironic. Hmmm... if JLG's comment was made a decade ago, and our dance teacher has 30,000 monkeys adding a k-loc or two to those five billion lines every day, then there are now about 21,500,000,000 lines of code to love, which seems about right, given how many different "please wait" messages there are.
lol
.NET Framework. Wikipedia is my primary example. :-)
.NET is really PHP vs ASP.NET and ASP.NET is actually a framework around the suite of .NET languages (ASP,JSP,C#,C++,and VB). So the comparison is a bit apples to oranges BUT while it is true that .NET can scale I believe that the LAMP stack, combined with Memcache can be more easily scaled with less hardware and less people bringing down costs. Plus, you'd be hard pressed to find a Microsoft trained .NET IT professional that actually knows what he's doing and isn't just another MS certified baboon.
You're fanboyism of PHP is much appreciated (as I am myself a PHP developer) but PHP is actually smaller. Don't be deceived. This is a GOOD thing. Less bloat = more performance. PHP + *SQL + Memcache will always pack more punch in a smaller package then the
Also I do have to point out that comparing PHP to
Huh?
Are you kidding?
http://msdn2.microsoft.com/en-us/library/xfhwa508.aspx
And that's just me randomly hitting a particular class. Most of them have examples.
The comparison to the human genome is interesting. The genome contains about 3 billion base pairs and 30,000 coding genes. As best I can see, .NET is quite a bit bigger: The closest thing to a gene is a method (an object that can be used, or not used, and which does something). The genome has 30,000 and .NET has 384,000. So even if it takes 10 methods to do what one gene does, they are equivalent.
.NET has 8,000,000 instructions. Given the roughness of the comparison, this is pretty close.
.NET :))
It takes 3 base pairs to code for a single protein, perhaps the closest we can come to an instruction. Each gene has an average of 3,000 base pairs, equivalent to 1,000 instructions. So we are looking at 30,000 genes x 1,000 instructions/gene or about 30,000,000 instructions in the genome.
The point here is that we are creating programs that are roughly equal in complexity to the human genome. If we were better programers, then perhaps we'd have come up with intelligent design.
Finally, it's worth noting that the functions are unknown for over 50% of discovered genes. It may be about the same for
The biggest plus to working in Java is that the documentation Sun provide is comprehensive (and once you figure your way around it) easy to access.
Microsoft is getting better but, for a framework that's quite clearly a java rip-off, they could have ripped its documentation style too.
You might not like asp.net very much, but saying that people who use it are not web developers is just a tad harsh, wouldn't you say? Or were you just not aware of it?
FTN "ASP.NET is a web application framework marketed by Microsoft that programmers can use to build dynamic web sites, web applications and web services. It is part of Microsoft's .NET platform and is the successor to Microsoft's Active Server Pages (ASP) technology. ASP.NET is built on the Common Language Runtime, allowing programmers to write ASP.NET code using any Microsoft .NET language."
I checked your ref. There are exactly two examples: for Visual Basic and for C#. I guess all the others are SOL.
Obama likes poor people so much, he wants to make more of them.
I don't know which is worse - the thought that you're making this comment without having read any of the extensive, working examples on the msdn site; or that you did read them and somehow still feel this way. .Net has plenty of flaws, but lack of documentation ain't one of 'em.
I am not seeing a C++ example in your link. Generic syntax is there, example? not really.
.NET developers stick with Visual Basic/C# ?
Or do 90% of
Obama likes poor people so much, he wants to make more of them.
Perhaps he was thinking of .Net as the asp.net framework; even though the asp.net-specific components are just the tip fo the iceberg (and not the focus of the FA).
Let me get this straight.
.NET lacks "internal logic" and "simplicity" after pointing to the article. Never mind that the article merely only reported statistics about the .NET framework instead of asserting that it, does, in fact, support your arguments. So this claim remains baseless, unless you're trying to say lots of types somehow means it lacks internal logic and simplicity. We are waiting for your keen insight on this point.
.NET that runs on non-MS platforms and is compatible at the bytecode level. What sort of examination have you done on the source code of it to determine that it has "simplicity" and "internal logic?" How does it meet those goals, yet have the same external API of .NET? How does it not suffer from "bloatedness" if it has at least as many publically available classes as .NET?
1. You argue that
2. Another user questions your assumption rather innocently.
3. You imply that they did not read the article (which is rather hilarious considering the previous point) and then, to add the icing to the cake, indicate you'd much rather work on Mono. Mono is a version of
We await your answers, mighty Naughty Bob.
This reminds me of an old joke:
Q: A Marketing executive and an RIAA lawyer jump off the top of a 50 story building. Who hits the ground first?
A: Who the hell cares?
laura, not a fan of .NET
What's the point? Is this any different from Java? Or is this simply a matter of throwing out some numbers and trashing M$? One poster made a good point: .NET and Java (my preferred environment) are both big and complex. On the other hand, at least in Java, an hour's research is all that's required to have a good enough grasp of file operations to write solid code. I suspect the same is true of NOT YET, er, .NYET, er, that M$ environment. On the other hand, I cringe when I hear about a Web app language doing SQL without prepared statements (that was today, BTW). Suddenly, all apostrophes are forbidden to the people entering data. Small, lightweight environments are great for small, lightweight applications. Java, and yes, .NET are necessary for large, complex applications. .NET any good, compared to other full-featured environments? I don't know, but that silly article certainly didn't contribute anything useful...
Is
Did you bother clicking the link to "Mono?" It links to this URL:
http://en.wikipedia.org/wiki/Infectious_mononucleosis
Wonder what the public key field is for?
GNU really has their work cut out for them here with their DotGNU project to provide a free implementation. Good luck rms and co; if you try hard enough, you might be able to implement it all before Duke Nukem Forever is released.
I did the same thing for Java
"God fights on the side with the best artillery." - Napoleon, Marshal of France - speaking truth to power
there's a lot of code. what else does this show / 'prove' ?
there's no place like ~
I am not seeing a C++ example in your link. Generic syntax is there, example? not really.
Personally, I'm glad the MS docs don't cater to the program-by-copy-paste crowd.
Higher Logics: where programming meets science.
Comment removed based on user account deletion
I have mod points, but this deserves about 10 of them so I reply in solidarity. .net programming work. It's ironic that their worst enemy is essential to working with their system.
The msdn docs are not enough, there are too many useless empty API pages. If it weren't for Google I couldn't do any
Often the most useful documentation and samples are scattered over a zillion forums (all requiring logins!), newsgroups, blogs, 3rd party books, etc.
This has always been the case with microsoft development libraries, but it's getting worse because early on (internet time) it was mostly just usenet.
Comment removed based on user account deletion
Working my first programming job, I had to take over a project written in C#.NET without any experience in the language. The goal was to communicate through an RS-232 port for sending and receiving some data, including text and numbers. Looking at the previous code, I saw some really long, confusing method of converting a string to ASCII and sending it through. I really took me by surprise since I had never seen anything like it, and I proceeded by looking through documentation. I was hoping for something real nice with fwrite, but I instead I had to jump through some hoops to figure it out. The problem wasn't so much finding documentation, but figuring out what methods I needed to use. I felt overwhelmed with the number of options that were so similar, some of which appeared like they would work but some contained a small caveat that prevented it from working.
On another note, I was perplexed when I used a switch structure and attempted to let the code fall through to another label. The compiler complained and forced me to write a goto statement (is there a more elegant want to do that?). A little later, a senior programmer was reviewing my code an criticized me harshly for putting in a goto where it should simply fall through. I literally had to show him that it would not compile otherwise in order for him to believe me.
Yes, because in .Net C++ is a waist of time.
You don't get a speed advantage with C++, C++ is much harder to read and much easier to screw up.
Plus you can just write the code much faster in C# and VB.Net.
Bad User. No biscuit!
String myString = "this is a string";
Char[] myChar = myString.ToCharArray();
Yeah, I can see why you'd have a problem converting a string to ascii.
As for the switch/case statement, it's part of the design. Fallthrough is a big source of bugs, so in C# they decided not to allow it. As for your use of goto's (and and senior programmer that believed you), that's just plain ignorance and lack of ability.
No offense, but if you can't take an example in VB and C# and figure out how to write the approximate version of it in just about any language (especially a .net language), you probably need a bit more in the way of programming language experience.
It's not hard, and the last thing we want is lots of copy-pasting going on.
kaens.blogspot.com
I'm partial to agree on this, if you're sticking in a managed framework, why bother with C++.NET when you'd get along fine in C#. However .NET does allow you to work unmanaged, compiling to native C++ if you feel like it (with decent support using Marshalers translating safe to unsafe and vice-versa). In fact the C++ native compiler in .NET is supposed to be one of the closest to the ANSI C++ standard if I'm not mistaken (I can't remember where I heard that one, don't hold me to it).
...in bed
Or do 90% of .NET developers stick with Visual Basic/C# ?
.NET projects at probably 10-20 different companies, and 100% of the .NET developers I've encountered used VB or C# (most using C#).
Probably more than that. I've worked on a lot of
The purpose of this complexity is to ensure the tool is obsolete before it is mastered.
Since .NET platforms have an average lifespan of what, 18 months? You could spend that much time in a bootcamp drilling namespaces and methods all day and not get there before it's time to enroll in the next one. 384,000 methods? 12,324 public classes? How many of those are deprecated? How many soon will be? And of course if you use this junk to develop for windows, try to remember not to get uppity and make a market with your product. You don't have a chance because the real tools are not here. These are just toys to keep you occupied. But look! They're shiny!
Do not invest your time and money learning trash like this when the turnover is this high. It's not worth it.
Help stamp out iliturcy.
Does "Working my first programming job..." ring a bell?
Of course he doesn't have a lot of programming experience.
Democrats or Republicans. They are both taking us to the same place and they are not afraid of us anymore.
One notable exception that I'll grant you is in their Vista Platform SDK docs. Especially the gadget API. But I tend to attribute it to the general train wreck that is Vista
I hate to say it, but whether "Naughty Bob" is normally a troll or not, I suspect he is correct.
MS has yet to show the type of design innovation that foregoes bloated code. Instead, when something doesnt work, or wasnt planned out correctly, they just add a bunch more stuff, then a bunch more, then a bunch more... then pat themselves on the back for the "innovation" which they equate with the number of things added.
Writing an extensible framework - and then extensions (or example extensions) would have been smarter, smaller, faster, and easier for true developers to implement.
The "Everything - including the kitchen sink" attitude does not work well in the computer world - the fact that their programs and apps are getting far more bloated, barely gain additional functionality (regardless of their claims) and getting far more resource hungry (while not adding significant functionality) is a perfect example - and one I think they are following with .Net
To me, it looks more like they are trying to prove that they can compete with, and surpass, all their .Net competition by sheer number of "features"/"capabilities" - which does not make it better. Their .Net framework already scaled horrendously to many types of implementations (like the Service/Customer tracking unit CompUSA used to use - as any of you who worked in Tech or Business Sales can attest to - from fond memories of running a rather simple report, going out for coffee and a quick breakfast, coming back, and still having 10 minutes to wait (of a total 30-40 minutes) - nor were the data sets that big, or the front end complex).
I'm far happier with using ________________ (pick almost anything else used in the non-Windows world), and far happier extending base classes and functions, over using pre-written bloatware versions.
But then again, besides the competition aspect, I think they are also trying to woo companies that can hire even less expensive "developers" since sooooooooooo many more things have been added making development a matter of point and click (and requiring even less actual development skills)... it seems more like a two prong attack against their competition.
Great, that's fine... nothing wrong with that - if it's not at the sacrifice of security, performance, and interoperability. But of course, it does sacrifice all of those... and really doesnt seem to do much at all.
So many of the new methods and classes are all stuff that the originals should have allowed the extensibility for to begin with. And so many should be variants on the same method (SOM anyone? Compare the SOM/DSOM design to just the first few lines listed in the article).
...so tell me again, how is "Naughty Bob's" post flamebait? No one who has responded to him has yet said why.
Feel free to mod this anything you want... doing so wont change reality.
StarTrekPhase2 - The Five Year Mission Continues!
Simplicity? Internal logic?
.NET is really designed to be a wrapper around all the different Windows services. A lot of things in Windows are rather difficult to program at the C or even the C++ level. The standard Win32 API isn't too bad to work with in C, but the windowing functions and the messages mechanism is enough to provoke tears. Really, Windows is terrible for programming in C compared to Linux, and so, at least .NET papers over all the crap.
.NET than in the native C++ in Windows. Writing services in C++ is basically torture. In .NET, services are very easy to write. In C++, cracking messages in Windows forms natively is a tad like pulling teeth. MFC is aweful and ATL/WTL are better, but, I would prefer a native C++ framework like what was done with BeOS. Still, GDI+ in C++ is pretty much the same as using GDI+ in .NET, except that .NET actually gives you more convenient handling of images and fonts. Files are much easier to work with in .NET than in C++. The Path combining classes are entirely welcome and those things are great. .NET String is better than the STL string, by far, and I really like that Microsoft stole the Java idea of a StringBuilder.
.NET forms are ugly and slow. The presentation framework looks cool, but, that's now two libraries for user interface, not counting all the web stuff.
Yes, actually. There's a ton of features in Windows at the SDK level and
Right off the wheel, I can think of a couple of things that are easier to do in
Of course,
Speaking of Java... I wonder how many lines of code are in THAT framework?
This is my sig.
Try printing the char array as integers, it's the ascii values.
All other things being equal, after trying to find anything in the MSDN, let alone the vaporware API I inherited (DAO Jet library, try to find it some time - they didn't actually document it, and what they did document, was neither complete nor useful. That's being charitable.), seeing a Javadoc is like stumbling out of the desert and in to an Evian bottling factory.
Sure, the J2SE API as HTML files is 60 MB or something, but at the very least, it's consistent, well laid out, the cross references make sense, and I can drill down to the objects that are probably what I need in about 3 or 4 'hops'. Also, how large is the MSDN now? I think I've got about 4 versions (VS 6.0 - VS2k8) each weighing in at something like 700 MB. Back to my desert analogy, it's like "water, water everywhere; but not a drop to drink" with the MSDN.
If I mod you up, it doesn't necessarily mean I agree with what you've said, sorry.
When the data really *is* variable, then the type is even more important. For instance, in an sql engine I wrote, a basic query is translated a list of arrays of ranges - a list of multidimensional boxes, one dimension for each key field. The low level indexing can use the array of key ranges very efficiently.
He got confused by Microsoft's renaming of ASP to .NET.
For whatever reason nobody has been able to explain, Microsoft decided to hijack an existing term for a top-level domain (thus the conflation with web development) and call their language that.
Apparently at the renaming meeting, Microsoft didn't have a Scotty to tell Dr Evil or whoever the project head is, that the name already was taken and had been so for many many years.
Having a large class library is a bad thing now? You don't like it when other people do work for you?
It's all properly namespaced (unlike some languages I could name), having a bunch of classes you don't need to use does not add to your mental footprint.
sic transit gloria mundi
.NET is the name of the framework, not the language. The languages are called C#, VB.NET, J# and F#.
J# is pretty much dead, no serious coder works in VB.NET if they have a choice - it's the language everyone takes the piss out of at MS-centric developer conferences - and F# is the OCaml like functional language which isn't actually part of the VS collection yet, but is available as a separate download. Which leaves you with C#, which is what most people work in.
Although I agree with the fact that the name was a pretty dumb choice, but we're stuck with it now. Still doesn't make the framework itself bad. It's actually very nice to work with.
.NET warms the cockles of my heart. Mostly by putting money in my bank account at the end of each month.
Yeah, I had a sig once; I got bored of it.
Moderation abuse? Anybody?
Help stamp out iliturcy.
Is there a tool like NDepend for Linux?
Is there one that can analyze both the source code (in C or C++) and the DB schema SQL that the code runs against?
That can show lots of classes, inheritance, tables and relations, without overwhelming the view?
--
make install -not war
Serious question: I have been programming to the WIN32 API for about 10 years now, and I *still* don't know how I am supposed to find information on how to do certain things. For example, let's say I want to delete a file by moving it to the trashcan. At this point I don't know what the correct way to do this is, but I know the possibility exists.
So how do I search for it?
I can Google until I see blue in the face, and maybe find the correct answer. But this does not seem like a good strategy; basically I just expect far, far better from the biggest software maker on the planet.
Or I can read through MSDN - but there is so much there that I can read for years without finding what I need.
So what is the "correct" way to figure out how to do stuff on Windows? Do I need to get a certificate or something? A special developer login maybe? Do I need to read specific newsgroups?
...on top of everything accumulated since .NET 1.0, making it even more bloated. It'll be fun watching them spin that as a feature. That's what I like about projects like Python 3000 - learn from the previous generations, don't absorb them.
Sam ty sig.
The most common .Net developer mistake now is that people don't bother finding the function they need -- instead they just reinvent it and waste everyone's time when maintaining that code later. The problem with 30,000+ items is that there's no good way to teach people where to look for something that's already in there. If it were organized in such a way that one could easily not reinvent the wheel, then it would be an awesome language. Without that, though, it becomes yet another way for people to create crappy date parsers.
stuff |
I'm surprised that .NET hasent crashed on 32 bit systems
I always thought that if the entire .NET framework were pictorially represented it would open the Seven Seals and be the harbinger of the Apocalypse.
Yeah, but I, for one, am stuck with a quarter million SLOC VBA(which is really a subset of VB 6) application that has no upgrade path to .NET. Furthermore, even if I could get out of VB 6, I'd have to refactor all the DAO calls to ADO, and that to ADO.NET or wrap them in an ODBC wrapper class. Sorry, I'm a little bitter about supporting someone else's custom Access application without any way out. The least they could have done is given me a way to get all the binary forms and reports out; sure, I can get the modules and class code, but I've no recourse other than remaking about a hundred forms. I understand that they moved on to .NET and there is no real way to port the code accurately, but they could have at least given me a way to export the design.
If I mod you up, it doesn't necessarily mean I agree with what you've said, sorry.
Given an experienced C# developer makes six figures, I'm not sure that is inexpensive.
Microsoft seems to focus on getting things done, rather than elegance. That's what you mean, I think.
Yet another example of poor moderation. This is a +5 Insightful when it is complete BS. The .Net doc is actually quite good and chock full of samples, most in multile languages. Thre aren't many development tools that can compete in this area.
Both the poster and moderator should really do their homework!
So, how do you really feel? ;-)
Star Trek is what happens when the human genome is released as open source!
It's better to vote for what you want and not get it than to vote for what you don't want and get it.
- E. Debs
Isn't that more of a shelbyville idea?
I know I'm late to the party and this probably won't get seen let alone modded up. However, this is a legitimate criticism of the .NET support system. Fortunately there is a search engine (which uses google) to search a subset of .NET-specific sites.
.NET
Search
I use it alot and helps separate the wheat from the chaff with regards to Google results.
A black hole is where God divided by 0
Karma: Positive. Mostly effected by cowbell.
In the installable documentation that comes with Visual Studio, examples for every language are provided in almost every case. But you're changing the focus of your argument - now you're saying they /do/ provide examples, but not in the language you want to see it in. Frankly, if you're not able to look at one language and do a translation into another, perhaps programming isn't the right line of work for you. The documentation isn't about the languages, it's about the framework and how to use it.
(Bah. Can't believe I'm defending .net, but I just want to see it crucified for the right reasons (like Properties).)
Fall through in a case statement in C# works like this: switch (test) { case "1": //do something
break;
}
case "2":
case "3":
{ //both will do something else here
break;
}
}
This should compile. Hope I understood your question.
My reply got mangled, That will teach me to use 'preview'
//both will do something else here
Fall through in a case statement in C# works like this:
switch (test)
{ case "1":
//do something break;
}
case "2":
case "3":
{
break;
}
This should compile. Hope I understood your question.
If I still worked at CompUSA (if there was even still one around), I'd be sure to let Microsoft who had a big part in writing it, know. Part of the software was Siebel's (ie: Siebel/MS joint project) and the other part was Microsoft's (ie: Microsoft's).
http://www.microsoft.com/presspass/press/2005/oct05/10-17SiebelAssemblyNETPR.mspx
Your experiences do not jive with numerous complaints about .Net/MsSQL's poor performance - nor with my experiences. But don't take that the wrong way - I am not saying your experiences are untrue. You probably have a setup that works under different load conditions... ours (CompUSA's) worked under conditions where 229 stores were connected to the database - a scenario where the MS products do not seem to scale up to very well (while oddly, Postgres, MySQL and DB/2 handle with ease).
Other situations I have compared with are custom EMS database engines... I have compared (using the exact same data) results on two different locally run with local data MSSQL setups with a MySQL setup through a network with an interpreted REXX engine generating the same reports).
MSSQL: 4min 37sec.
MySQL: 14 seconds (including network time and an 80,000 line HTML report being sent).
The report reads a LOT of data and generates MANY pages of output - hence the 80,000 lines of HTML.
The results were not even remotely close. Both MSSQL based software were written and compiled using MS's Tools, accessing local data via the local, compiled program... (while the REXX engine is just interpreted - through a web server no less - over a network from the client to the database and report engine). Now it is possible BOTH companies just did a very poor job in writing their software - while I did a better job (I wont claim to be great at db stuff, but I do like optimization planning when creating a table or search query). One of the competitor's software used a database structure very similar to ours (but who knows what weird stuff was being done in the query) - while the other one uses 126 tables for the same data (compared to mine and the other's 9 tables)... and all 3 (mine and theirs) required "sorting", loading, and calculating the reports from the entire data set (ie: it's not like they were grabbing too much data - they and I both have to grab all of the data to generate the report).
Your experiences apparently vary... but those are two of mine (one where there are a couple hundred users, the other with one user at a time, and an identical data set).
StarTrekPhase2 - The Five Year Mission Continues!
Oh, I must have missed that.
I also forgot that one can get a programming job without much in the way of programming experience.
kaens.blogspot.com
Good DB admins make the money they make for a reason -- administration makes a HUGE difference in the performance of databases, and many of the techniques used to tune database performance are nonstandard and nonportable. Even if you had "exactly the same setup" on both databases, one would have been configured in an inferior way, because each database requires its own brand of trickery. 4m37s vs. 14s could, potentially, be merely the difference between skillful and unskillful database administration.
.NET create the bad data model, or did it merely enable morons (or bright yet ignorant people) to create a product? There's nothing wrong with enabling morons (or bright yet ignorant people) to get a little bit of work done, even if it doesn't result in blazing performance. Even allowing for that difference, it's obvious that a 126-table model was solving a larger problem than your 9-table model. A design that doesn't scale is a crappy solution for *any* problem, but you have no evidence that you could have solved the larger problem well -- you solved a different one. You probably solved exactly the problem your company needed solved, which is possible for an insider to do, but a difficult thing for an outsider, even when creating bespoke software. How can you expect us to believe that .NET was the problem when the business analysis behind the .NET implementation was clearly drastically wrong?
.NET had anything to do with the performance differences you saw. Alternative explanations (bad data modeling, bad requirements analysis) are screaming in your face, and you have no way of ruling out the possibility that the MSSQL database was poorly administered. Yet you are eager to implicate .NET (though you have now introduced MSSQL into the mix as well -- what exactly does its performance have to do with .NET?) The engineers are just anti-M$ whiners, right? Well, I guess sometimes they are. And that's a big part of the reason why CTOs end up wrapped around a M$ salesman's finger, floating in fantasies of systems that scale effortlessly and internal tools that magically integrate when you need them, while their engineers scream, "No! Wake up! Wake up!"
Worse, it seems you're talking about drastically different data models. Did
In any case, the massive difference in performance is a common-sense giveaway that you aren't looking at a meaningful comparison between platforms or database engines. I'm a Linux guy, and I personally hate Visual Studio and its code generators, but your comparison is exactly the kind of thing that gives upper management an excuse to cut engineers out of the loop on technology platform decisions. There's no evidence that
For some definition of "experienced" that excludes the vast majority of working C# developers, I guess. There are forces in my company pushing for more .NET development, and one of the advantages that has been touted for .NET is that it's supposedly too expensive to hire good Linux developers. Of course, our current .NET development effort is pretty sad. I don't think that's a coincidence. Good development managers go for quality over quantity, so it's natural that in a given company the perception that one platform is superior goes hand-in-hand with the perception that developers for that platform are expensive -- all the results are coming from the team that hired a handful of good developers instead of a herd of lightweights.
Microsoft focuses on marketable, saleable products. Their pitch is always amazing. They promise miracles. Often, the products are just an honest attempt to live up to a pitch that got way out of hand. When you ask why something in Visual Studio is done a certain way, the answer too often is that it sounds better that way, or it works better in the best-case scenario (i.e., the demo scenario).
The biggest villain in this way is Visual Studio integration. It sounds good to have every single Microsoft code generator and development tool integrated into Visual Studio. Everything is right there under your hands. The downside is that EVERY bug fix to EVERY tool you use has to be released as a patch to Visual Studio. You may not get the bug fix you need when you need it, simply because it's too tightly integrated into Visual Studio to fix easily or it's just the wrong time in Visual Studio's patch/release cycle. Hmmm, maybe it would have been better if it hadn't been integrated quite so "well."
The second biggest villain is invisibility vs. transparency. Visual Studio often makes it difficult to see what's going on behind the code generators and development tools. Then, when you finally find the guts, it's not nearly as nice as it would be if they knew you'd be looking at it. It's like sneaking into your host's private bathroom and finding out how messy they REALLY are when they aren't expecting guests. For the sake of making things super-easy and super-amazing in the optimistic case, all of the troublesome cases (bugs in the code generator, need to get to the bottom of an ambiguous or misleading error message, need to parameterize the code generation in a way that Microsoft did not and could not predict) are made nearly intractable. Why? It isn't because the optimistic case is the predominant one. Murphy's Law still holds, even when using Microsoft development tools. It's because the optimistic case is what matters for sales and marketing. The optimistic case is what you sell . The imperfect case is what developers live with. It's clear which one Microsoft cares about more.
[P.S. To top this off with an intemperate rant: The real biggest Microsoft villain is not Microsoft software, but it is a Microsoft product in a sense: blinkered Microsoft-only developers. You know who I'm talking about, the ones who never program on anything but Microsoft platforms and treat Microsoft "educational" marketing materials as if they were impartial advice from God. They never see the messy failures of Visual Studio because they dogmatically follow the optimistic case completely disregarding business requirements, performance requirements, and interoperability requirements. "Oh, we had to do it this way, because...." NO! You "had" to do it that way because that was the only straightforward way to do it using Microsoft tools, and it never occurred to you to push back against the tools instead of throwing the project
Good DB admins make the money they make for a reason -- administration makes a HUGE difference in the performance of databases, and many of the techniques used to tune database performance are nonstandard and nonportable. Even if you had "exactly the same setup" on both databases, one would have been configured in an inferior way, because each database requires its own brand of trickery. 4m37s vs. 14s could, potentially, be merely the difference between skillful and unskillful database administration.
It could be... but I admitted that was a possibility. :-)
Worse, it seems you're talking about drastically different data models. Did .NET create the bad data model, or did it merely enable morons (or bright yet ignorant people) to create a product? There's nothing wrong with enabling morons (or bright yet ignorant people) to get a little bit of work done, even if it doesn't result in blazing performance. Even allowing for that difference, it's obvious that a 126-table model was solving a larger problem than your 9-table model. A design that doesn't scale is a crappy solution for *any* problem, but you have no evidence that you could have solved the larger problem well -- you solved a different one. You probably solved exactly the problem your company needed solved, which is possible for an insider to do, but a difficult thing for an outsider, even when creating bespoke software. How can you expect us to believe that .NET was the problem when the business analysis behind the .NET implementation was clearly drastically wrong?
You would think that was the case - but in actuality, my tables store more than twice the info as the 126 table model... and leave out absolutely nothing that is contained in the 126 table model. That one is poor design. The other one (the other competitor's 9 table model) is pretty identical in layout.
All three solve the same problem (ie: the report in question) which MUST (by law) utilize the same data, calculate it the exact same way, come up with the exact same results... so no, there is no difference there. Some of each tables are not needed for the report - and arent called at all. The others (which are called) require the same exact data...
In any case, the massive difference in performance is a common-sense giveaway that you aren't looking at a meaningful comparison between platforms or database engines. I'm a Linux guy, and I personally hate Visual Studio and its code generators, but your comparison is exactly the kind of thing that gives upper management an excuse to cut engineers out of the loop on technology platform decisions. There's no evidence that .NET had anything to do with the performance differences you saw. Alternative explanations (bad data modeling, bad requirements analysis) are screaming in your face, and you have no way of ruling out the possibility that the MSSQL database was poorly administered. Yet you are eager to implicate .NET (though you have now introduced MSSQL into the mix as well -- what exactly does its performance have to do with .NET?) The engineers are just anti-M$ whiners, right? Well, I guess sometimes they are. And that's a big part of the reason why CTOs end up wrapped around a M$ salesman's finger, floating in fantasies of systems that scale effortlessly and internal tools that magically integrate when you need them, while their engineers scream, "No! Wake up! Wake up!"
Perhaps... the REXX implementation is running on eComStation and MySQL v5... the Windows .NET implementation is running on a considerably more powerful machine (2 faster cores, compared to one for eComStation - 2GB RAM compared to 1GB for eComStation) and MSSQL. I have found (well, so has IBM for that matter) that for things like that, OS/2 outperforms Windows by a large margin - and XP uses a lot more resources
StarTrekPhase2 - The Five Year Mission Continues!
Do you even lift?
These aren't the 'roids you're looking for.
Thank you. This is pure Goodness.
I liked C# 3.5 all right, but 4th Edition has already made it obsolete.
I used to find slashdot delightful, But my feelings of late are more spiteful; My comments Sarcastic The Iconoclastic Keep Modding to Plus Five (Insightful)
Trying to install linux on my microwave, but keep getting a kernel panic...
Seriously? MSDN, when it finally loads, does have documentation for the simplest use cases of various methods. However, there is little not much of a community of people discussing things and helping each other solve problems anywhere. So once you go past the simplest use cases, you're out of luck. In PHP, ugly though it may be, most times when I have a problem I can Google and find someone else who's already solved it. Also, php.net not only has solid language documentation, it has many helpful contributions from other coders because it allows them to add follow up comments.
.NET. Generally, once I have the final code for a .NET program, it is simpler and shorter than the PHP equivalent. However, to get there I have to waste time trying to find my way to some obscure setting. .NET makes many hard things easy, and many easy things hard.
My experience is that in real-world cases of solving problems and providing robust examples, PHP's online resources are far superior. I develop in both languages, and I'd love to have better resources for