Online Thoughts

Why I decided to add Google AdSense

2010-09-27T02:18:00.001-07:00

Hello!

I decided to add Google AdSense for the very reason that - hopefully - that will turn in some income.
I have no idea of how much income I will actually be having, yet I'm eager to try :-)

So, if you want to support me - feel free to examine the proposed ads :-)

Andrew

Revamped Blogging

2010-09-27T01:46:00.000-07:00

Ok apparently I am now ready to revamp this blog.

While I still am a Delphi Win32 developer, I will also be talking about ASP.NET MVC and Linq along the way. I might even be talking about other things, too!

Ok so here I am again, ready to roll!

Andrew

A tale of the impossible

2006-02-09T11:22:00.000-08:00

Ok, let's be less paranoid and more optimistic.
Delphi has to find a new home.
Some buyer has possibly already chimed in, maybe this thing is in the contract's finalization stage.
What happens now? *Who* this buyer is?
Hopefully not Microsoft, which would just kill Delphi, maybe not Google nor Apple.

Let's have a fancy idea. Let's explore the unlimited and impossible, after all it's all speculation taking place, right? Nobody in the community has clear inside info apparently, and those who possibly do won't disclose them soon, will they?

So, it's time for speculation.
Better, it's time for the impossible :D

What I would gladly see as a result is a nice sponsor, a private company, which could fund a venture along with "senior" Borlanders(almost ex Borlanders, however).

This (im)possibility appeals me very much as end result, it would justify the geek dances, and would probably be very well applauded by the community.

To make the "impossible" a bit more realistic, I'd add that fabolous(as in "very few people think he's real"<g>) DavidI said that Borland already had a separate financial division, so that it's already a tale of two companies since a bit of time.

But let's go a bit higher: what if this allowed a few ex Borlanders to come "back home"? Clearly, Anders H possibly wouldn't, but that's not said for other members.

Ok ok ok I know it's impossible...

... or not? :-)

Buy Borland Developer Studio 2006...

2005-12-03T16:24:00.000-08:00

... WHY?

Many people encourage to upgrade due to bigger stability, features, etc... which is ok.
Yet, there're a number of reasons to wait for BDS 2007(or whatever it'll be called).

First of all: everything that is in 2006 will be in 2007. Thus, you lose nothing waiting.
Secondly: you don't get dotNET 2.0, which is not really a huge loss, you know, but
actually ASP.NET 2.0 looks nice.
Thirdly: you'll get all the goodies of 2007, too.
Fourthly: if you wait a year, you'll have time to save money and buy Software Assurance, too, which will take BDS 2008 too to your door, for free.
Doesn't seem a bad deal, to me.

All in all, if you don't really need it, just wait. Many peers I know are doing just fine with Delphi 2005, so why upgrade now?

Regards,

Andrew

Delphi SKUs: Pro, Ent or Architect?

2005-10-31T06:06:00.000-08:00

Uhm... actually, was it for me, none of them.

Let me explain: right now Delphi has become huge and three editions only probably
aren't enough. As it's been highlighted in the past, it's all about choices.
Fine then, please let me really choose. If I develop desktop applications for Win32, I'm
probably much less interested in dotNET - thus giving me ASP.NET is basically useless -
while it would be alot more interesting to get DataSnap, for example.

Give us an IDE at a very low cost(to allow young people to get started) . Let us choose à la carte what packages we want to buy, discount on bundles(if I get to buy stuff for - say - $600, you make me pay $500? That's for Borland to figure out, really).

There're several reasons to be willing to do this: first of all, as I said, three editions seem too few for the current choice of technologies. I can in fact split Delphi in at least these profiles:

Delphi Desktop applications using Win32
Delphi Desktop applications dotNET(which I don't think is good, but however...)
Delphi Win32 Web Development using WebBroker
Delphi Win32 Web Development using Intraweb
Delphi dotNET Web Development using ASP.NET
Delphi dotNET Web Development using IW for ASP.NET
Delphi dotNET Compact framework applications
Maybe I've missed a few

And I'm not detailing package wide, just using common sense.
That's at least 7 different "profiles" and I probably missed a few, like Delphi
Win32 C/S developer and Delphi dotNET C/S developer. That's about 9 now.
Maybe more. By providing only three editions you're actually limiting my
choices rather than widening them.

Back in the Delphi 5 days, Borland offered ADOExpress as a separate package for purchase.
This could be done with ECO and other pieces as well.

Why not do it again, on the whole packages that are "worth it"?

Cheers,

Andrew

Why would I want to use ECO?

2005-10-25T16:49:00.000-07:00

It's been pointed out, from Jesper on this same blog(see previous post's comments) and in several Borland forums(and during 24hrs), what ECO really is.

ECO is, simply put, a new way to write applications. It has all the features of an OPF, plus a powerful constraint language, OCL(which is common practice in the MDA world), which is
meant to make the life of us programmers easier.

The most compelling reason to use ECO, then, is the fact that a fair amout of code(namely: all the persistence code) gets out of the way to let us concentrate on coding the application.

There're other reasons, too, though: for example, you can use your own already existing database that you can evolve to use ECO.

You can also(you most times actually will) model your business classes and map them onto one or more persistence layers(I'm talking the full blown ECO here) directly from inside Delphi.
This means that, if a customer asks for an Oracle database, oplà, tell ECO to use Oracle and you're done.

As you can see, these are all extremely good reasons by which you'd want to use ECO.

There's one main issue here though: ECO is about dotNET, not Win32. This means that you'll have to use it in a managed environment. This might not be what you really want from your
apps, especially when you're not server side.

This becomes really especially true if we're also considering that DeXter Pro will contain just one persistence layer instead of multiple: the XML files.

This is indeed a problem. Assuming you might want to take on the risk and try to deploy to desktop PCs, you're facing the "Win9x challenge": will my application just run somehow or
won't it even start?
Please let me remind you(is it really necessary? Hope not!) that the average computer user is plenty full of viruses in his/her machine and that Win9x is unstable most of the times and with very poor hardware dotation(little RAM, little HD, etc). You might trying by limiting your app to Win2000+ but then... computers running Win2000 are still below actual computer horse power(not as much as Win98 machines, but... well you get the idea!). Are you sure that it's going to run smoothly and without problems? Obviously not(I'm talking about "structural" problems which are not to be raised by single applications). I've collected some informations at the 24hrs of DeXter, where an ECO team member told me that, by itself, this library doesn't add up very much to dotNET requirements, but still... thus, the only "reliable" option is to limit to Windows XP. Not only that, but you must make sure that you have enough RAM(please read Mark Russinovic's post about dotNET applications memory usage!) and decent hardware components
(big HD, etc).

Now, on to the technicalities about dotNET. You'll end up choosing WinForms or VCL.NET .
Either one, to me, doesn't seem a great option. Why? The (in)famous JIT compiler. Why this is a problem is *very* easy to understand: dotNET is precompiled in IL code. This code then gets translated on-demand when you're going to use it. Lastly, it gets cached till you close the application. This means that if you restart your computer or anyway close the application, the next time you'll have to go through JIT again! Now, given how many times you're bound to restart Windows(just think of the updates, let crappy software apart), you can see where the problem is.
Let's consider something relatively "simple" in dotNET: managing XML files. These are usually managed through DOM rather than SAX, because you will normally need the tree. At least, I still have to find a situation where I didn't need the tree. Maybe XSLT transformations are better off with SAX, but I don't do that usually ;-).
DOM engines for XML all suffer by one element, which is critical in dotNET applications: Memory consumption. Small files(in Win32) already get to use a fair amount of memory, let alone big ones. Go figure in dotNET. Plus, the code to load them is fairly slow(keep in mind
that XML files might be using several different encondigs, thus a parser has to check for
encoding compliance and so on - and they can't just assume you're using UTF-8 and it has to check for each node and for all its attributes, be it leaf or not).
Another problem, is that dotNET doesn't have pointers. Yes, I know, that's supposed to be a "feature", yet I like pointers :-) because they speed up some of my work. All Delphi classes are "pointer based"(actually that's what you're managing when you write var SL: TStringList, since the compiler will translate that to var SL: ^TStringList) and there're a few third party components that make a brilliant use of Pointers(Virtual Treeview being the one that comes to my mind first). Such components can't be ported to dotNET(obviously) and that's a problem for Delphi programmers, since many of them are using that and other components that can't be translated easily to be managed ones.

These are just a few of the problems that you may encounter in dotNET. But we were talking about ECO, now let's see some "ECO-specific" reasons by which you won't probably want to have ECO desktop applications. ECO makes use of WinForms and if you've explored some more detail about it(I'm a Delphi 2005 user) you'll have discovered that you can't include WinForms code straight into your applications the way you used to with Win32 packages. You can - instead - do that with VCL.NET . This means, basically, that if you want to deploy such applications to the market, you have to deploy ECO packages too. This means - potentially - that if I'm a D2005 user and I download the demo for free I might be able to add ECO packages in the IDE, thus having access for free to something I would have to pay for otherwise. Now, how am I going to make sure that you don't have Delphi 2005? I can't - clearly. This means I can only do components which expose some ECO persistence property to work, but this also means that I have to restrict my market to components development that will be used by a vastly reduced market, namely D2K5 Architect owners and upcoming DeXter owners. The other way you can safely use ECO for the time being is ASP.NET applications. You build a website, then let users subscribe to your services. With Highlander, this is apparently bound to change - because ECO will be available for VCL.NET which is a good thing.

Starting to "see the light"(at least, what I think to be such) now? :-)

Thus, the problem really boils down to what you're planning to do with it.

There're advantages too, such as the fact that even if you have DeXter pro(making components), that counts very little: just expose the correct properties and anyone using ECO would be able to change the persistence mechanism, even though you can only provide XML persistence. If you're writing webservices, you can however detatch your ASPX service from ECO persistence and be good with it. Actually, if you have a set of classes that "hide" ECO to the service, this seems very good to me :-) You can however upgrade if/when the website is having enough subscribers, till then you might have separate XML files(where appropriate) for each user.

See, all this actually makes the "right decision" fairly difficult to do, considering all of the above.
I don't think to have the Truth in me, thus I'll just tell you what I would do if I had to choose.
My best bet would be to go for components, because even if the market for them is fairly shrinked, managing, updating and advertising a website can be quite challenging, while a message on Borland Forums now and then to advertise your components would probably suffice for most businesses. Also keep in mind that managing a website offering a subscription service must be done on reliable hosting - maybe redundant? - plus you also have to improve the service itself, leading to potential problems with customers who don't like the service's changes,
while component customers can simply stick to what they already have without upgrading.

Once ECO will be in VCL.NET, though, this all might(and probably will) change.

Cheers,

Andrew

ECO and DeXter

2005-10-23T14:12:00.000-07:00

Well... it's been a while, actually, since I last blogged here.
I decided to chime in again, because I looked at a video, featuring Tim Jarvis' daughter using ECO to produce a homework management application. I strongly suggest that you watch it - but mind you to either use Internet Explorer or download it - since it won't show up in Firefox, you're warned.
Alexandra(Tim's daughter) has done an excellent job using ECO, I strongly recommend you view the video - it's worth it.

For those of you who don't yet know what ECO is, from my fairly superficial knowledge, here is a short description: ECO is, in essence, an Object Persistence Framework.
Yet, it's a full featured one, with lots of goodies, already here and upcoming. It has all the "classics" of such tools, plus a few very nice things like complete integration with the Delphi IDE. This means that you can design your model inside Delphi and then code straight away, even though with time the needed coding becomes less and less(at least for the "average" application).

Let's see the pros and cons.
Pros: It allows you to basically define most things visually, you can have multiple target databases(or persistence media, anyway) and if you're in the higher SKUs, then you get nice little things like data-hubs which, in the end, are a handy way to manage data oriented webservices.

Cons: it's only existing for dotNET. This is, though, a disadvantage only up to a certain point. Let me explain. It's highly unlikely that you'll be using ECO for a desktop application, for the simple reason that it would be fun to see an eco-powered application run on Windows 98, and beleive me, Win98 is still well spread out there.
Instead, you'll be using ECO mainly server side, maybe with SharePoint Services(btw: do you know anyone who can actually use that stuff? I'd have a few questions to ask :-P) or just in an ASP.NET application. dotNET on the server side isn't actually a bad idea, after all a server is supposed to be fast, powerful and all, thus it would make sense to get a higher end machine for a multi-thousands dollars application. Plus, dotNET has the other advantage(server side) to be in a managed environment and if an application happens to have a problem, that's not likely going to bring down the whole server(which is a good thing ) or make it dead crashing.

Plus, having critical applications in a managed environment makes it a lil safer(read: viruses/exploits/etc remarkably more difficult) even though this doesn't substitute
basic security precautions(like: why let anybody do anything in a webservice without
being logged in?).

Well, since I'm at it, I'll also be commenting a bit about DeXter :-)

I know Borland since... uhm... be it 1991 maybe, when I started programming.
I've always thought Borland had brilliant development tools, even though I
really didn't like the most recent strategies very much(read: Kylix 4 needs to be
produced :-)).

Since Delphi 8, though, things got really, really, really scary.
Much scarier than in the past. This is because of several reasons, imho:

First of all, because not many Delphi programmers trust Microsoft(yes, I'm in that camp)
Secondly, because MS is trying to impose something(dotNET) in both server and client machines, which means throwing a fairly big amount of code really out of the window.
Thirdly, since MS has $100 million shares in Borland, all this sounded like the final death of Borland as an independent company
Fourthly, because Delphi 8 was really awful according to many commenters(I didn't buy it, thus I don't know first hand)

Yet, now things seem to getting back to normal, and we even have a real ROADMAP! wow!
It's maybe the first time that Borland actually does one in 14 yrs(that I know of).
Actually, there also were the barbarian updates from Allen Bauer for Delphi 2005 which made the product even more enjoyable than the three patches(which had already made it quite enjoyable). Those are also already available in DeXter, acutally the D2005 ones are a backport, thus things should have been vastly improved in that respect.
Plus, there'll be an ECO "lite" version even in Pro SKU, which is appealing for me.
Anyway, time will tell what Borland was able to do and if it's worth being with them.
Considering that there even is a CompactFramework preview compiler for Delphi 2005, things just look right.

What to say... I'm eagerly waiting and if I can manage I'll be surely getting a Software Assurance as well - according to the roadmap it should be very good value :-)

Bye,

Andrew

Customer UNcare

2005-03-24T09:42:00.000-08:00

Prologue
Some time ago, I bought SQLServer 2000 Developer Edition, because you
never know what your business needs will be and I found it to be affordable
enough to go for it(70 euros).
Some more about me: I'm a fair and loyal customer when it comes to buying
stuff that I use business-wise. That's one of the reasons by which I upgraded to
D2005 Pro SKU, since I couldn't afford Architect.

What happened
Yesterday I realized that I couldn't find my SQLServer CDs(or are those DVDs? Not
sure about this, but I didn't mind investigating at the time) so this morning I called
Microsoft Customer UNcare for enlightment about how I could get my CDs back.

The response, summing up the discussion, looks like this:
"You have to fax us copy of the complaint filed to police officers, copy of your
paper license, serial number and a photo of the product box". Yes, they
asked for the photo of the box. They continued: "This process will lead to us
allowing you to purchase again the CDs". Yes, they cost 30 euros and you're
kindly allowed to buy them again.

Premise on the conclusions
I do not and am not planning to endorse piracy in any way but, here are my
thoughts.

My thoughts
Now, let's be honest. What could possibly stop me from buying a pirate CD and use my
legal serial number with it? I mean, I already bought it legally, I can use my legal serial
number with it. I can use the pirate CD as backup copy. If you're willing to know why
I'm more leaning towards buying it again(yes, that's what I'm going to do), it's simple:
SQLServer CDs include a few things other than the client and server themselves, like
Reporting Services, service packs and so on. And I don't want to lose on them.
Plus, I can make sure something like that(losing the CDs) won't happen ever
again with the product.
Now, on with my thoughts about Microsoft attitude.
I can understand fighting piracy, that's what those requirements boil down to, but I
strongly beleive in the concept that you're innocent before you're demonstrated
guilty. Nowadays, it looks more like that you're considered guilty unless you
prove to be innocent and that's just plain wrong in my opinion.

Anyway, this buffled me quite a bit, I never thought I'd be requested to go
through all this hassle to get CDs back.

Side note: when I lost my Delphi 6 CDs(yes... :D I'm a bit distracted :D), Borland
asked for my purchase proof(obviously) and just sent CDs back to me with no
expense on my side. Thus, kudos to Borland for that.

Andrew

Dear setups...

2004-12-12T15:04:00.000-08:00

How many applications do we install monthly?

A bit, most people will say. Yes. Quite a bit, in my case.

And how many times does it happen to you to have to click Next for a long time?
Yes... me too, obviously.

Setups are darn boring.

They're boring because in most cases we just want to get the thing installed and don't care about the slightest details. Over 20 yrs of setups around the world and nobody seems to get this
very simple thing: the most of the time people don't care about customizations.
That's the problem. What's so wrong about having a simple message box asking at startup:
"do you want to do any modification to the setup?" If you answer yes, then the plain
setup windows will follow, otherwise it will JUST INSTALL THE THING!

Then, if you like it, you can always remove it and re-install and be picky and modify each small detail about it. But that's afterwards.

Other thing: most of the time, setup programs ask a variety of questions which, in principle, should be asked at the first run. Please stop that. It's awful.
It's just a time consuming step that makes people lose their time.
Yes, eventually you'll have to answer those questions, but at least give an option.
Ask: "Do you want to preconfigure the program?". If I answer yes, then go on.
Otherwise, please do refrain from obliging me to configure on the spot.
I might have other things to do and be unwilling to leave the computer opened.

Now, after all this, what is a setup in my opinion? A setup is a set of steps that
prepare your application to be started and operated flawlessly.

Example: when you install the Operating System, in my opinion, driver installs are not part of the configuration, but of setup, because they enable the computer user to "use" the OS to its uppermost extent. License acceptance, for example, should be part of configuration.

Registering an OCX is part of setup, but having registry keys containing other things shouldn't be part of setup( well, registry shouldn't really exist in the very first place, but that's another story... ).

Please, let all of us cooperate to get back to setup sanity.

Cheers,

Andrew

Few considerations on the current and future Delphi and Borland

2004-10-24T10:09:00.000-07:00

Recap of the situation

Delphi 2005 is due out around November this year. Fine. It'll contain, according to several Borlanders, three different personalities to work with. Fine. There'll be Pro, Ent and Architect editions. Not really fine. Why isn't it fine? After all, Delphi is mainly used from professionals and for learning there's Lazarus. That's not really fine for several reasons that I'm going to list:

Lazarus and Delphi are different products with different goals and different user base
Delphi is light years ahead of Lazarus, for historical reasons and for funding reasons
Delphi has a technology allowing new components to be installed/uninstalled seamlessly in the environment. With Lazarus, each time you want to add one or more components to the IDE you've got to recompile it.

These are not the only reasons, but the ones I consider most relevant. There's the lack of a Personal edition for the Delphi product line and that's not a good thing. Some people say that it's just not possible to add a Personal because it would look too much like Professional one.
This is true only till some extent, because I don't think the problem lies on the "personal" side of the product, but on the professional side.

Let me explain.

When I have a look at the Pro feature matrix column, I always feel there's something missing.
Just an example: MIDAS wasn't available to the Pro users. Unfortunately the current feature matrix for D2005 is a bit confusing and I'm unable to say if there's now or not.
ASP.NET controls are not available to Pro users. It just seems like Borland leaves us on the edge of the canyon, always waiting for us to jump. That's not a nice feeling.
That's what makes, in my opinion, impossible for Borland to make a Personal edition.

While the new enhancemets are really most welcome, it's probably missing on Borland side the "feeling" for the small shops and single developers. They dind't probably learn a lesson from "Integrating the Enterprise", did you, Borland?

What really beats me off here is understanding what is so wrong with professional users and,
more importantly, how would you define a professional or an enterprise user.
It's very easy these days to do webservices, for example, with RemObjects. Now, if I make a webservice, am I a professional or an enterprise customer? Standing from Delphi editions point of view, I'm an Enterprise customer :-) but I maybe am just a pro under the "pocket" point of view. I agree that some things are just pointless in "Pro" editions, for example the ECO model.
Another example that perfectly shows the situation: I'm a developer with a LAN at home.
Now, I want to target Interbase Server, I can't. That's because the Pro version comes only with Interbase Desktop. Thus, I can't access - for example - from other computers in my home lan my Interbase server because of that. And if I want to make a test I have to do it on my machine, which inherently leads me to choose Firebird because I can target it freely using the whole potential of my LAN. Why then wonder that Borland revenues come less from Delphi and Delphi-related stuff and more from other things? Another example? Ok.
You have to be a software house to become a Borland Technology Partner. Why is this wrong? Simple: because only BTPs can make a request to be included in the Companion CD shipping with Delphi. Thus, I'll obtain not even a chance to try and let my freeware or shareware stuff be
visible. Since there's no way to get onto the companion CD if you don't have financial resources to do so, then you won't likely upload stuff to CodeCentral unless you're really interested in giving away for free some of your works. That's, imho, probably one of the reasons this is wrong. Plus, you're entitled to leave a message for Borland when you upload something, but you never get a response back. At least, I never received one and I uploaded 4 things. I put always the same message. Is there anyone reading those messages? I strongly doubt it. Not to speak about the "Get Published" section on BDN. If you want to be able to publish, you have to FAX the agreement. LOL that's plain crazy, come on! I live in Italy, faxing to USA is an intercontinental call. That's what has been mainly stopping me from writing anything for BDN, and I would have a few things to say. I'm still using Delphi 6 and I'm plain happy with it. Oh yes, I'd love to be able to play with Kylix shipping with D7, but I can't, because the contability raises an EFinanceException when I press the "Buy" button :-)

Ok, that's all for now.

See ya later!

Andrew

Components aren't always a good thing

2004-08-26T12:16:00.000-07:00

Many Delphi programmers build applications through alot of components.
While this may be good on some cases( try doing DevExpress things without
using components :-) ) other times plain classes will do just well.

The reason many programmers don't use classes is that they relate OOP to
components wich - imho - is incorrect.

Classes can be very useful for run-time tasks where you need extensibility and polymorphism.
Encapsulation just comes in the bundle, if you do proper OOP.

Let's see an example: say you have to make a program that process text commands.

You could do it in this way:

Type

TCommandProcessor = class
protected
procedure ProcessCommand( S : String );
public
procedure LoadCommandsFromStream( S : TStream );
procedure LoadCommandsFromFile( const FileName : String );
end;

Then go on implementing it this way, with your ProcessCommand method getting *HUGE* and
unmantainable when time goes by. Now let's have a look at a, imho, better design:

Type
IMyCommandSource = interface
function GetNextCommand : String;
end;

TCommandBase = class
protected
procedure InternalProcessCommand( ACommand : String );virtual;abstract;
public
constructor Create;virtual;
procedure ProcessCommand( ACommand : String );
end;

TCommandClass = class of TCommandBase;

This acts as a base class for all commands. The Create constructor is
marked virtual( please do remember to call "Inherited Create" at some point in it ), so
that you can do there all of your command-wide initializations.
Using a protected method to make the actual process is senseful because that way you
won't need to change public methods when changing internal implementation.
We also defined an ICommandSource interface, this way *anything* implementing that
will be able to be passed along as a parameter when we'll use the interface.

Now we can create a list of commands:

Type

TCommandItem = class
public
property Name : String;
property CommandClass : TCommandClass;
end;

TCommandList = class
private
FList : TObjectList;
public
procedure AfterConstruction;override;
destructor Destroy;override;
procedure AddCommand( Name : String;ACommand : TCommandClass );overload;
procedure AddCommand( AnItem : TCommandItem );overload;
property Item[ Index : Integer ] : TCommandItem;
property CommandByName[ Index : Integer ] : TCommandClass;
end;

Now, you might want to make this a singleton, to share the same instance throughout
your program. Using CommandByName you can write something like this:

var Cmd : TCommandBase;
begin
Cmd := MyCommandList.CommandByName[ 'MyWeirdCommand' ].Create;
end;

Quite handful, uh?

Now you can build your command processor, using ICommandSource to get your
next command and then splitting the whole thing using a delimited string list.
Since Delimiter and DelimitedText only work for D6+ as far as I can recall, then you
might be well served using the CommaText property and have comma separated
commands.
The first string in your list will usually be the command, during processing you'll be
able to set relevant properties and be well.

Using a solid class-oriented architecture will save you big time when you'll be
adding new commands.

Needless to say, you may want to add your own event handlers, so that your
program can react to specific things happened or going to happen.

This wasn't a complete program on purpouse, just because I wanted to throw some
hints about paths you may want to explore.

It's up to you.

Cheers

Support Borland Developer Network

2004-08-25T17:24:00.000-07:00

John Kaster on his blog asked us for more cooperation if we want to see BDN
improving. This sounds like a fair request to me: if we contribute stuff, rate articles, etc, that's a very good way to make BDN stats improve to the point it could gather more and more attention.

I am a long time Borland customer( back to TP6 ) and I can only be happy to see BDN get more funds and be shaken to rebirth in a new life.

Thus, you're strongly encouraged to rate articles, submit new stuff to CodeCentral and the like:
your voice won't go unheard!

John, keep up the good work!

Andrew

Small tip to detect if MS Word is installed on the PC

2004-08-25T08:54:00.000-07:00

This piece of code was written for an Italian newsgroup, but I feel like sharing it here.
The basic working is simple:

- It detects if a .doc extension is registered
- If there's any, it goes checking which program is associated with it
- If the program is different from word.exe then it returns false
- Otherwise returns true

Here is the code:

procedure TForm1.Button1Click(Sender: TObject);

var Reg : TRegistry;

  KeyToOpen : String;

  Value : String;

begin

Reg := TRegistry.Create;

Reg.RootKey := HKEY_CLASSES_ROOT;

if Reg.OpenKeyReadOnly( '.doc' ) then

begin

  KeyToOpen := Reg.ReadString( '' );

  Reg.CloseKey;

  if Reg.OpenKeyReadOnly( KeyToOpen+'\shell\open\command' ) then

  begin

    Value := Reg.ReadString( '' );

    if Pos( 'word.exe',Value ) > 0 then

      ShowMessage( 'Word is installed' )

    else

      ShowMessage( 'Word isn't installed' );

  end;

end

else begin

       ShowMessage( 'Word isn't installed' );

     end;

end;

Obviously, you'll have to include the Registry unit in one of your uses clauses,
preferably implementation one( to avoid unnecessary noise in the interface part )

Cheers

Why you shouldn't be using MSXML parser

2004-08-25T02:57:00.000-07:00

I already went through this topic in the Borland Forums, but I thought I would
replicate my feelings again on this topic.

The very first good reason to avoid it is that it's not native.
While this may not seem a compelling reason at a first sight, just think it means
that you'll have to either ship MSXML with your program, or let the users download it,
neither of which seems appealing to me, as long as you have several native ones which
will compile straight into your exe.

Another good reason is compatibility. What is it going to happen if Microsoft messes it up
changing the interfaces? Wouldn't be the first time, wouldn't supposedly be the last one.

There's also another extremely valuable reason: what happens if some day an exploit gets
found which will allow an attacker to make something to your PC?
MS reputation in regard to exploits isn't brilliant to say the least and this is a true
concern for me.

If you thought I was finished... well you were wrong :-)

MSXML behaves disaccording to the standard sometimes, allowing malformed XML
files to load correctly. Yes, I'm not joking. This happens mainly with charachters out of
standard( there're quite a few of them which aren't defined ) and that MSXML will
accept silently.
To get an idea of what I'm talking about, have a look at this.

Another issue: cross platform development. If you use MSXML alone you may
have a really hard time making a Linux version out of it. The issue can be
greatly mitigated the exact moment you start using TXMLDocument component tho.

Nope, I'm not finished yet, there's some more things to say :-)

With the advent of dotNET , COM will get discarded, and using a COM based parser
doesn't look the best choice as to now.

Ok, now I have finished :-)

Cheers

Indy, ICS or Synapse?

2004-08-25T00:11:00.000-07:00

This is a common question hanging around the various Delphi groups in the world.

I don't think to have the definitive answer, but I just want to point out a few things about
them: try using TIdHTTP to download files subject to redirection. You'll see that it ain't that
easy.

ICS, instead, does the job extremely well and reliably.

Though, Indy is a full blown component set and that's obvious that the larger a project
grows, the higher is the chance to find something not really working as expected.

Plus, most of the bugs you can find in Indy are likely to be there for slightly "exotic"
situations, that means on plain standard ones it behaves well enough( at least for me ).

Now, ICS is less "flooded" with protocols/tools/whatalike, so that may be an issue, especially if
someone isn't really into socket programming. I've been told, though, that things are changing.
I have no reasons as to now to beleive this isn't true.

Synapses is not a set of components, but a set of classes. This has several advantages and
drawbacks. First of all, its footprint is *way* smaller than ICS or Indy. Thus, if this is an
issue, you may very well want to give it a try.
Since it's not component based, adding event handlers isn't exactly a chill, especially if we're
talking of *many* events.
It lacks the richness of Indy and I think its classes are extremely useful particularly under two
circumstances:

1) RAW Api programs
2) DLLs

In the above scenarios, I think Synapses is close to unbeatable.

Now, what to choose? It really depends on you, I guess.

I mostly use Indy, but I'll be posting on Synapses as soon as I'll have some time to
delve through it thoroughlly and have a couple of projects done with it.

Thus, I'll keep you posted on this.

Borland, win32, dotNET and Delphi

2004-08-24T15:36:00.000-07:00

Let's take a few steps back and have kind of a bigger picture down hands.

During last years, Borland has gone through several turn-arounds.
First was born Kylix and then D7 and eventually D8. Meanwhile, a few Borlanders went
over to Microsoft. While it surely was a deal of a lost to let them go for Borland, yet this
made a carrieer shift possible for others. The very first name that comes to mind is
Danny Thorpe, now Chief Scientist.

There's been quite of a movement lately in the Delphi community, since a noticeable
slice of customers showed their disappointment for what D8 didn't deliver.

Not only that, but some of them also perceived the new IDE as slow( which hasn't ever
been the case before, even with a lot of components installed ).

Right in these days, there's been alot of noise from Delphians about what Borland
should do to get back the slice of developers who have migrated or are migrating to
Visual Studio back.

Imho, the problem doesn't really is in what Borland should do, but what it can actually do to
improve the situation. It surely can't( though it's been proposed ) open source some of its
products due to the eventual loss of IP.

It can't even give out Delphi for free, or change its internal roadmap to satisfy a few developers.

Surely, Borland can show commitment to its developers and do it in several ways:

1) Give us a knockout D9( which should include Kylix 3 ) showing Win32 isn't a dead end for them. Anybody presumably has a very different and subjective view about what a knockout D9 should be. I'll expand on this later.

2) Send out more frequent updates - this can be done relatively cheap by setting up
public betas which can be downloaded and installed at clients' PCs.

3) Involving us with more programming contests, more challenges and/or by providing
superior services of some kind. These should be included in Delphi price for, say, one
month or two and then renewable through a subscription fee.

4) Funding BDN more aggressively and making Delphi help files more accurate and
much better worded.

5) Organize more chats with the Delphi R&D Team, so that they can get direct feedback from
users.

6) Improve QualityCentral

7) Allow single developers to submit components/software for inclusion in the Companion CD.
There could also be a "voting" system for this, so that BTPs get included automatically,
while single developers would need to get votes to be included.

8) Allow for public surveys, enable a few of them at once, and make the results
available for the community.

These were just a few offhand ideas that could help in making things better for us.

As to the aforementioned "knockout D9", this is my whish list:

01) Include my CDS Creator as a design time tool( , ok this isn't compelling )
02) Stabilizing and documenting the OpenTools API
03) Providing a real "make" tool, with possibility to generate HTML documentation on the
fly( this would later allow for easier integration into CHM help files or whatever is the
hype at the moment ) even at the build time.
04) Include a menu item to access Borland Forums and easily publish content on BDN
( which actually is a quite long-taking deal )
05) Restructure dataset classes to fully support interfaces
06) Enhance support for DLLs/Packages to be switched from one to another easily
07) Enhance support for forms, so that they can be made persistent in different
formats than DFM( which can still remain the preferred format for design
time stuff )
08) Enhance the new component wizard( didn't change since D3 I guess )
09) Add an item in the Help menu to detect actual Delphi version and listing all the
installed updates( it could be shown in a memo box so it can be cut&paste around )
10) Improve to-do lists( you can definitely do better than that, come on... )
11) Quality Central client in the Tools menu
12) XSLT expression builder( would help alot )
13) Fix the damned library path issue
14) Add a CodeCentral menu to manage your submissions( even with a very basic VCS to
keep track of changes in them )
15) Enhance WebBroker( how about the one webmodule issue? )
16) Make WebSnap use easier
17) Add a few classes to ease use of Design Patterns in Delphi( Singleton, MVP, MVC, etc )

Yes, I know my whishlist is huge :-)

You may be wondering why I didn't mention dotNET stuff in my whish list.
That's because I think that dotNET isn't just about at the development stage
"they" would like us to see it at.

For example: did you know that dotNET applications get JIT-ted everytime they're
started? Yes, every time they're started. So - say - if I have to run an application
that has a hell lot of plug-ins, each time I do it it'll be JIT-ted.
Another thing: did you know that each time an assembly gets loaded, it's not
shared with the other instances running the same assembly version?
Right, if you have - for any reason - to start two applications which share an
assembly, you'll have TWO copies of it in memory. At least, that's what I've been
understanding after a talk with some Italian MVPs.

Here is the big question: Is dotNET worthwhile?

The answer may seem a boolean one( yes/no ) but in fact we refer to "dotNET"
while we should be addressing each and every different aspect of it on its own.
That's because dotNET is an extremely complex platform, made up of different
frameworks and concepts behind them.

I've been playing with C# a bit now, and I can say I don't really like it too much.
Resembles too much C++ syntax( which isn't good ) and it's always like you're
going to use printf again.

My main real problem with dotNET is that( as most times ) MS behaves in opposite
directions: on one side, it standardizes C# and alot of dotNET concepts through
ECMA, on the other MS keeps filing patents of any kind and then, here you are, it
encourages the use of OpenSource stuff regarding dotNET.

I don't know you, but I for one would like to be able at any time to say what's
going on and not be surprised the moment later with a contradictory move.

It always seems the pacts with MS are never clear, and this sheds a dark light on
every "good thing" coming from that side and that's one of my main reasons( a part from
being a passionate Delphi developer ) to not go for the Visual Studio route.

I''m not going to scrutinize dotNET in detail here, mainly because these are my
impressions after a very short time playing with it.

Last, a couple of considerations about D8: Borland had basically no choice other than
letting it out soon, whatever the bugs where. After all, we all know the "even release"
problem since TP days don't we?

Though now, it's time for "when it's ready" answer back. We want our Borland back.

Cheers,

Andrew

First Post

2004-08-24T14:57:00.000-07:00

Hello!

Finally, here I am blogging :-)

Ok, I'm a bit unsure about wether I should be doing this, anyway here I am ;-)

Er... well I guess the best thing is to introduce myself: I'm a 27 yo Italian, Delphi programmer and now exploring the dotNET side.

What will you see here? Whatever passes through my brain and I feel like sharing.

Why would you want to read my blog? I don't know, but if you do and post comments I
definitely don't mind :-)

See you on this page, and hope you enjoy it!

Andrew