Gridding .NET

Windows .NET grid computing

Microsoft and grid computing

http://www.eweek.com/article2/0,1895,2009167,00.asp

and what if MS bought Digipede? I do hope they do!! I've used similar .NET grid computing software before in a financial services environment which could easily saturate 400-500 CPUs of parallel work on 4-5 different OSs and CPU types.

previous posts about Microsoft Windows Grid computing

Microsoft and open source

After reading a bunch of posts from josh
http://weblogs.asp.net/jledgard/archive/2004/08/20/217992.aspx
http://weblogs.asp.net/jledgard/archive/2004/08/24/220028.aspx
http://weblogs.asp.net/jledgard/archive/2004/08/25/220716.aspx
especially this one
http://weblogs.asp.net/jledgard/archive/2004/08/27/221716.aspx
and articles
http://www.eweek.com/article2/0,1759,1640591,00.asp

I believe that MS is moving in the right direction in regards to OSS.

The right strategy would be to offload non vital technologies to a "pool"/foundation of all MS partners like ISV,OEMs and large system integrators, so that it can be regulated by some form of commercial contract.

The benefits would be several:
1) redeployment of precious programming resources onto more important things like LH, Yukon and Whidbey and Windows security.
2) better community, developer and ISV relationships
3) perhaps better products(documentation, testing, less bugs) where software original project was underresourced
4) good PR (why not)

My favorite technology to drop off would be WMI,
1) because it's a VERY buggy (just see all the fixes in XP SP2)
2) clumsy, if not badly designed

.NET SOA enterprise framework - FABRIQ

Clements Vaster & Co. are working on a super clever piece of software -FABRIQ

http://staff.newtelligence.net/clemensv/CategoryView.aspx?category=Technology%7CFABRIQ

MSDN Product Feedback Center coming soon !!(Codename "Ladybug")

As noted at http://www.eweek.com/article2/0,1759,1617344,00.asp 
finally there will be a central place to submit bugs, feedback and feature requests.

ASP.NET controls - Granular security

1) you need a repository for your permissions ie a database structure
2) design user, page, group then usergroups,pagegroups tables linking all with proper keys
 a) associate users to groups and groups to pages in composite tables usergroups,pagegroups
3) add permission columns for view, add, update, delete - one column for each permission - setting 0/1 for allowed/not
4) build custom(extended) base page which
 a)does the lookup of user on these tables to retrieve permission sets
 b)loads the permissions into session
 c)authentication of user ie if user's group does not have permissisons on page
5) build custom(extended) webcontrols  which
 a)map a (design time)property to the above permissions
 b)verify the above permissions
 c)do something based on b) eg hide, set enabled=false, change CSSClasss attrubue or other cool stuff like hiding EditCommandColumn and ButtonColumn in a datagrid

6) add custom assembly to VS.NET

.NET Refactoring - revisited

.NET Refactoring threads

http://www16.brinkster.com/messydesk/db/refactvb.asp
http://addressof.com/blog/archive/2003/11/03/249.aspx
http://www.panopticoncentral.net/archive/2003/10/31/233.aspx
http://ea.3leaf.com/2004/04/im_getting_worr.html
http://weblogs.asp.net/jlerman/archive/2003/11/17/38021.aspx
http://weblogs.asp.net/dreilly/posts/35319.aspx
http://dotnetjunkies.com/WebLog/darrell.norton/articles/3374.aspx
http://weblogs.java.net/pub/wlg/1283
http://thomasfreudenberg.com/blog/archive/2003/11/17/279.aspx
http://geekswithblogs.net/evjen/archive/2003/11/07/444.aspx
http://scottwater.com/blog/archive/2003/10/28/10415.aspx
http://www.eugenebelyaev.com/begblog/general/000050.html
http://scottwater.com/blog/archive/2003/01/02/141.aspx
http://www.iunknown.com/000406.html
http://www.panopticoncentral.net/archive/2003/11/04/235.aspx
http://geekswithblogs.net/evjen/archive/2003/11/07/444.aspx
http://techedbloggers.net/Directory/Bloggers/Stephen_Forte/709.item
http://weblogs.asp.net/juntao/archive/2004/02/17/74965.aspx
http://weblogs.asp.net/cnagel/archive/2004/02/04/67548.aspx
http://scottwater.com/blog/archive/2003/01/21/157.aspx

Marketing by subversion and beta software

<blurb>
Technology like many other fields is entrenched in trends and passion for one set or another.
Now and then disruptive technologies enter the market "subverting" currents technologies
because of (lower) prices, ease of use or simply social trends.
In the enterprise new tecnologies often appear at first when introduced by individuals with strong preferences.
These "installations" start perhaps hidden on some box, then get "evangelized" to other users,
which then build applications around it and generally grow to depend on it.
Then when management wants to curb it, the business line users revolt, management gives in
and gets the extra licences to do it properly.
</blurb>

How can marketing help with the subversion?

- get that beta out no questions asked
- do some "training" version of Virtaul PC + W2k3 + server software for easy deployment
- help the "subvertives"

Eweek has a good article
http://www.eweek.com/article2/0,1759,1568279,00.asp

Right tool for the the job - NOT (Management perspective)

Ponderings about our integration woes:

What's the point of having 750 different best of breed tools/technologies if the first time one needs to integrate stuff it's like doing black magic.  

Apache (Foundation) vs .NET(ASP.NET): Final smackdown

I've had a loook at the Apache website and found their incubator program quite intriguing.

I'm quite fond of open source as a means of collaboration, fellow developers cameraderie, (academic) research and
covering overlooked niches, but not as a a political/ideological means to harm commercial companies or anticapitalism.

Cleared that up, Apache foundation comprises a whole range of technologies battling .NET or MS products.
There are groups working on Apache, the webserver, PHP ,Phyton and ultimately Java in the Jakarta project.
Apart from these majors, there are several hundreds of subprojects, including most of the leading open source frameworks
for building and testing software(Junit, Ant. Log4J etc etc). Even .NET is represented with Log4Net.

As a coalition Apache has lots of credibility, good software and the support of all ABM vendors and users.

Now, as an evangelist of MS technology - despite my regular rants - I see Apache as a formidable nemesis for
MS, but also view Apache with some envy as there is nothing comparable in the .NET world.

It would make a wise business decision for MS to clone the setup. The pros would be able to create an independent conglomerate of the top 20 openly available projects like Ghengis, OpenCF,DNN ,.Text add some of the MS magic like the Application Blocks, Project Niobe and mix with INETA, MVPs and the other technology stalwarts of the MS influence sphere.  

Scoble?

links:

http://weblogs.asp.net/sandyk/archive/2004/03/02/82914.aspx
http://weblogs.asp.net/rjacobs/archive/2004/02/09/70355.aspx
http://weblogs.asp.net/rosherove/archive/2004/02/10/70706.aspx
http://weblogs.asp.net/markcli/archive/2004/01/12/58041.aspx
http://weblogs.asp.net/jezell/archive/2004/02/10/70828.aspx
http://weblogs.asp.net/jledgard/archive/2004/03/03/83645.aspx

Why .NET developers don't grok advanced stuff

Picking up on Sam Gentile's post I completely agree that there are not many developers understanding the advanced features of .NET like Remoting, transactions, queuing, LDAP and encryption stuff. Java folks do much better being accustomed to products from enterprise vendors like SAP, IBM, Oracle.

By comparing these thesis with my own experience doing gigs in many places I put it down on 3 things:

1) DNA
Many .NET developers come from a line of business environment, web design or client server world where most programming is pretty simple as the code then resides on one or two layers , does things like validation and some data access.
 
2) Vendor education
Most articles focus on doing the simple stuff or how to do things like a datagrid pretty.

3) Toolsets
VS.NET for all it's cosiness is targeted at beginner/intermediate developer, helping with things like data access and doing simple stuff simpler. Enterprise templates are inside, just pretty well hidden.
Architectural guiding or enforcements is non-existant. The wizards to facilitate writing microcode are ok, but where are the wizards for doing the advanced stuff like Remoting, transactions, queuing, LDAP and encryption?

Anecdote: Before joining the .NET world I worked on the Oracle JDeveloper IDE. Jdeveloper allows you create queues with routing and all from DB tables or objects with a wizard generating stubs both inbound and outbound. And then
routing and stuff, all graphically like designing a DTS package in SQL Server. Where's a thing like that in VS.NET? (perhaps White Horse modelling will do that !!??)

On the architectural side, VS.NET doesn't really help for large projects unless the (experienced) developers creates the layers as projects himself. VS.NET should create the 3 or 4 layers automatically as new projects or slice in different namespaces as WebForm1.BLL.cs, WebForm1.DAL.cs,WebForm1.UI.cs in one project and then nag the user if the architecturally wrong classes(like ADO.NET) are placed in the presentation layer.

Original post
http://samgentile.com/blog/archive/2004/02/12/11304.aspx
Others
http://udidahan.weblogs.us/archives/015193.html
http://weblogs.asp.net/cosgood/archive/2003/04/23/5994.aspx
http://staff.develop.com/halloway/weblog/2003/01/23.html
http://blogs.geekdojo.net/pdbartlett/archive/2004/02/12/1007.aspx

Rebuttal

http://blogs.msdn.com/alowe/archive/2004/02/24/78878.aspx

Software Development Process Automation

Reading Scott Hanselman's blog  about Validation some thoughts came up.

What do you do when you want to avoid tedious repetitive manual tasks?   Automation
What do you do when you want to avoid tedious repetitive manual tasks in Software Development?  Complain

One of the things I learned - I have to give due to a former mentor - is to automate some tasks I find extremely tedious and time consuming. I am willing to spend an extraordinary amount each time a new technology comes up to adapt an existing piece of code (Application Blocks) or build my own.

Some of the things that come to mind are:

Validation - www.peterblum.com has a nifty package
Data Access
Look and Feel

here and here I wrote soem more about software dev

Hardening ASP.NET - ASP.NET querystring parameter tampering - Part 3

Parameter tampering:

UPDATE!!! possible solution:

secure Querystring
http://www.dotnetjunkies.com/HowTo/99201486-ACFD-4607-A0CC-99E75836DC72.dcik
http://www.dotnetjunkies.com/Forums/ShowForum.aspx?forumid=4922

Vote here and here on MSDN  to have this functionality included in ASP.NET

From my quick and preliminary investigation of URLSCAN today I found out that the QueryString part of the url is not protected

To alleviate this issue of GET parameter tampering in ASP.NET I wrote up a little code with does the following:

- get the QueryString part of the URL
- decode it (HtmlDecode)
- parse out all the bad input
- limit the length of the queryString to minimum necessary

Since the HttpRequest class is sealed/not inheritable there are 3 ways to do it:

1) Write HttpHandler to deal with it
2) Extend Page class and set this functionality in prerender event
3) Write your own ISAPI handler in unmanaged code

I put one item on my personal .NET wishlist

Good Design vs common sense (OO vs good design)

Software Productivity

I believe that productivity of a software development lyfecycle can be achived twofold:

BUTTOM-UP:
such thing come to mind:
- wizards
- code(classes/methods) refactoring
- easy of use of development tools
- Intellisense

TOP-DOWN:
- blueprints
- architecture/design refacturing
- lyfecycle tools(analysys, design(ie UML), testing, deployment, code coverage tools, FxCop and the like)
- patterns and other code re-usability mechanisms
- frameworks (like the Application Blocks)

In essence, the BUTTOM-UP approach helps adoption and personal satisfaction for a developer, while the TOP-DOWN assures the overall project -ilities(testability, ... you know the drill).
The BUTTOM-UP helps in getting small tasks getting done faster, while the other cuts down on errors on the foundations of a project.
That doesn't say which one is better, or which produces more or saves more time, that is probably dependent on the size of the project.
In the .NET vs Java world you could say that Java has a more TOP-DOWN ways of seeing things - J2EE is a blueprint and then all the JSRs - while .NET heavily depends from the combination of the framework and the developer tools. While both started at the soft extremes, they are now both moving to cover their weak spots, Java to get more developer friendly and .NET towards more the TOP-DOWN view on productivity.

I believe the race is on.

IDEA#.NET is coming... and better refactoring for .NET

VS.NET and &quot;purdy code&quot; aka .NET refactoring

What would you like to be included in Whidbey?

IMRO, the features should be divided into "REFACTORING" as a technical code surgery and a "purdy" part, which would do some other jobs like sorting code in the editor, enforcing advanced styles et al.

a good blog post is at http://www.panopticoncentral.net/PermaLink.aspx/9bd4cecd-1dee-4175-bb36-396a0b196b18

some interesting posts:

http://weblogs.asp.net/aaguiar/archive/2003/06/03/8168.aspx
http://thomasfreudenberg.com/blog/archive/2003/11/17/279.aspx
http://dotnetjunkies.com/WebLog/darrell.norton/articles/3374.aspx
http://www.panopticoncentral.net/archive/2003/10/31/233.aspx
http://addressof.com/blog/archive/2003/11/03/249.aspx
http://ea.3leaf.com/2004/04/im_getting_worr.html
http://www.iunknown.com/000406.html
http://weblogs.asp.net/rosherove/archive/2003/11/17/38004.aspx

http://dotnetjunkies.com/WebLog/stefandemetz/archive/2004/05/22/14232.aspx

.NET and code refactoring maintainability (links)

from google (http://www.google.it/search?hl=it&ie=UTF-8&oe=UTF-8&q=code+maintainability&spell=1)

http://www.advogato.org/article/258.html
http://www.iam.unibe.ch/~scg/Teaching/ESE/Material/codeInspections/maintainabilityChecklist.html
http://www.strayneuron.com/mt/archives/000033.html
http://www.softwarecraftsmen.com/blog/archives/000010.html

Monitoring profiling and tracing ASP.NET applications

I found it quite difficult to monitor ASP.NET applications.

Besides the performance counters we did some custom classes doing following:

- pinging the app with webrequest

- monitoring the aspnet_wp.exe process itself using the proces info capturing process restarts, pages served, max RAM used

- connection string class appending pagename and user to OLEDB connection string to see who's using the database spids

- reading the machine event logs

- IIS logs analysis

- the usual 10-15 logs tracing/logging exceptions, user input, et al

 What I'd like? (Hm, about time someone did a .NET wishlist !! )

-some control says if the numbers of performance counters are good or bad (perhasp something with green, yellow or red traffic lights)

- perhaps some minimal runtime profiling saying which parts are not so well behaved (I know, but testing never catches all scenarios)

Has anybody implemented some other interesting code?

UPDATE: Good article  + tools

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnaspp/html/monitor_perf.asp

Enterprise grade ASP.NET Development and code reuse

The solution I describe was implemented in a financial services organization and
is used in several applications.

This development concept is meant to create solid code and save on development by half in componentizing and reusing code.

For each iteration features are moved up the source three and retested.

Good software practices are highly recommended to manage this process
... you should know the fluff (versioning, testing, ....)!!

To start we create a new namespace called ENTsystem, which will be the first level or enterprise-wide root.
 
Then we do another one as APPSystem, which is the application level.

In the ENTSystem, we extend the Webcontrols as empty classes first, by prefixing each level with ENT
e.g. ENTSystem.ENTWeb.ENTUI.ENTWebControls.ENTDatagrid

We do the same for the APPSystem namespace, this time by deriving from the
ENTSystem classes.
e.g. APPSystem.APPWeb.APPUI.APPWebControls.APPDatagrid

The ENTSystem will be the enterprise root, will the APPSystem will be the
Application-level root -co-maintained by all dev groups - and the APPSystem WebControls are the lucky ones, which will be imported in Visual Studio.NET.

Another important class to be extended is the Page class. This can be specialized into IntraPage and ExtraPage to be able to use them in both Intranet and Internet scenarios with different security models within.

At this point features can be added.

One item we did was:
e.g. Setting the CSSClass to the ID in all controls so that we could create a nice style sheet with classes named after the controls and making the controls pretty ;)

I would recommend getting a first application ready before distributing the root DLL, so that some basic features get into the ENTSystem root classes and the developers get comfortable with the development process.

Obviously, this component-structured development can be applied to any namespace in your organization.

After 2 years of using it my organization has surely been able to maximise developer productivity and avoid reinventing the wheel over and over.

That is all for the first part. It's a very simple overview and the implemention is simple too., really.

Next time I will write some stuff about the security model we used out Intranet scenario.

posts about code reuse:

http://weblogs.asp.net/jkey/archive/2003/07/13/10030.aspx

http://weblogs.asp.net/bgold/archive/2003/09/08/49811.aspx

http://weblogs.asp.net/lhunt/archive/2003/12/17/44124.aspx

http://weblogs.asp.net/mscilipoti/archive/2003/02/13/2363.aspx

http://www.reusability.org/blogs/brian/

http://blogs.msdn.com/ricom/archive/2004/01/08/48796.aspx