473,561 Members | 3,772 Online
Bytes | Software Development & Data Engineering Community
+ Post

Home Posts Topics Members FAQ

advice needed for modularized development

Hi,

I am sitting down to design our next set of internal apps. I would like to
approach this in a way that would allow me to break logical parts of the
application that handle specific tasks into modules. For example, assuming
we have 4 main tasks to accomplish:
- Printing
- Editing
- Viewing
- Inventory Management

Each of those tasks would have an associated UI(User Control) with all
relevant UI controls, for example printing would have printing options,
printer names, etc.

My motivation for wanting to make these separate is that different
combinations of these modules need to be rolled together into applications.
For example, at my desk, I would want an application that would support all
4 tasks, while in the shop, they only need Printing, Inventory and Viewing.
Someone else might only need Viewing.

Rather than develop all modules under the same project and build separate
binaries with various modules enabled or disabled, I would rather have a
project for each module, then a project for each combination of modules and
include the modules that I need.

I suppose this is actually a sort of plug-in architecture that I'm looking
for. I haven't ever done anything like this and am interested in how most
of you would approach this? Anyone know of any good articles or books on
the subject?

Thanks for reading,
Steve
Jan 24 '06 #1
5 1700
Well the first thing you should look into is the notion of Add-Ons in
general (maybe do a web search for it). This will help you understand what
AddOn's are and different ways of implementing them.

Next, take a look at Interfaces because that is a core part of Add-On
implmentations. You will need a common set of methods (aka an Interface)
that can be used to access the Add-On.

Here is an example of an Interface and a way that you could use it in your
application.

+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++
interface IAddOn
{
String Name(); //Returns a human readable name of this AddOn like
"Printing"
String Description(); //Returns a brief description like "Allows
Printing of internal documents"
bool Startup(); //Performs any init/startup code that is needed and
returns true/false as a success result.
bool Shutdown(); //Performs any shutdown code that is needed and returns
true/false as a result.
void Show(); //Informs the AddOn that it should display itself.
void Hide(); //Informs the AddOn that it should hide itself.
void Execute(String cmd); //Tells the AddOn to execute the given
command. cmd could be an xml string or anything?
}

Now if you are going to have a standard application that these AddOns will
be part of then maybe you could use a menu system to show the available
"options" that are intalled. The menu system could be an actual menu or
maybe just different buttons on a form that are clicked on.

The application could look at the files in a specific directory (maybe
\AddOns) and use Reflection to load and create an instance of each of the
files contained in it. Each file (assembly) would have a class that is
derived from the IAddOn interface so you could determine what class you
should instantiate. Or maybe you have a config file that contains a list of
assembly files and class names that should be loaded.

After loading each of the AddOns the application could call Startup() on
each one so that they could do any initializing they needed.

Using the Name() member of the IAddOn interface you could dynamically add a
menu item that the operator could select in order to activate the AddOn.

When the operator selected an AddOn from the menu you could call the Show()
method or maybe the Execute() method to have the AddOn peform it's task.

When the application is closed down you would want to call Shutdown() so
that the AddOn's could do any uninit type of stuff they needed like closing
files, etc.
+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++

The nice thing about this type of setup is that you could have different
types of AddOn's. Maybe you have an interface used for user selectable
options, and another interface for background utilities.

Or, maybe you want to implement some sort of secutity mechanism. The
Interface could have a method that takes a username and returns true if it
is allowed to use the AddOn. This way you could have one application with
all the AddOns available but the user logs and only sees what they are
allowed to use.

Kind of a brief overview of this type of development but maybe it can give
you some insite?
"Steve" <ss*@sss.com> wrote in message
news:ev******** *******@TK2MSFT NGP09.phx.gbl.. .
Hi,

I am sitting down to design our next set of internal apps. I would like
to approach this in a way that would allow me to break logical parts of
the application that handle specific tasks into modules. For example,
assuming we have 4 main tasks to accomplish:
- Printing
- Editing
- Viewing
- Inventory Management

Each of those tasks would have an associated UI(User Control) with all
relevant UI controls, for example printing would have printing options,
printer names, etc.

My motivation for wanting to make these separate is that different
combinations of these modules need to be rolled together into
applications. For example, at my desk, I would want an application that
would support all 4 tasks, while in the shop, they only need Printing,
Inventory and Viewing. Someone else might only need Viewing.

Rather than develop all modules under the same project and build separate
binaries with various modules enabled or disabled, I would rather have a
project for each module, then a project for each combination of modules
and include the modules that I need.

I suppose this is actually a sort of plug-in architecture that I'm looking
for. I haven't ever done anything like this and am interested in how most
of you would approach this? Anyone know of any good articles or books on
the subject?

Thanks for reading,
Steve

Jan 24 '06 #2
Very nice, that is a great overview!
I too had thought of the single "host" application that would host the add
ons and make them availablew based on the current users role.

I printed your message, it's a nice overview, I'll read it a couple times,
thanks for the post.

Have a good one,
Steve
"C.C. (aka Me)" <me@home.com> wrote in message
news:ts******** *************** *******@comcast .com...
Well the first thing you should look into is the notion of Add-Ons in
general (maybe do a web search for it). This will help you understand what
AddOn's are and different ways of implementing them.

Next, take a look at Interfaces because that is a core part of Add-On
implmentations. You will need a common set of methods (aka an Interface)
that can be used to access the Add-On.

Here is an example of an Interface and a way that you could use it in your
application.

+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++
interface IAddOn
{
String Name(); //Returns a human readable name of this AddOn like
"Printing"
String Description(); //Returns a brief description like "Allows
Printing of internal documents"
bool Startup(); //Performs any init/startup code that is needed and
returns true/false as a success result.
bool Shutdown(); //Performs any shutdown code that is needed and
returns true/false as a result.
void Show(); //Informs the AddOn that it should display itself.
void Hide(); //Informs the AddOn that it should hide itself.
void Execute(String cmd); //Tells the AddOn to execute the given
command. cmd could be an xml string or anything?
}

Now if you are going to have a standard application that these AddOns will
be part of then maybe you could use a menu system to show the available
"options" that are intalled. The menu system could be an actual menu or
maybe just different buttons on a form that are clicked on.

The application could look at the files in a specific directory (maybe
\AddOns) and use Reflection to load and create an instance of each of the
files contained in it. Each file (assembly) would have a class that is
derived from the IAddOn interface so you could determine what class you
should instantiate. Or maybe you have a config file that contains a list
of assembly files and class names that should be loaded.

After loading each of the AddOns the application could call Startup() on
each one so that they could do any initializing they needed.

Using the Name() member of the IAddOn interface you could dynamically add
a menu item that the operator could select in order to activate the AddOn.

When the operator selected an AddOn from the menu you could call the
Show() method or maybe the Execute() method to have the AddOn peform it's
task.

When the application is closed down you would want to call Shutdown() so
that the AddOn's could do any uninit type of stuff they needed like
closing files, etc.
+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++

The nice thing about this type of setup is that you could have different
types of AddOn's. Maybe you have an interface used for user selectable
options, and another interface for background utilities.

Or, maybe you want to implement some sort of secutity mechanism. The
Interface could have a method that takes a username and returns true if it
is allowed to use the AddOn. This way you could have one application with
all the AddOns available but the user logs and only sees what they are
allowed to use.

Kind of a brief overview of this type of development but maybe it can give
you some insite?
"Steve" <ss*@sss.com> wrote in message
news:ev******** *******@TK2MSFT NGP09.phx.gbl.. .
Hi,

I am sitting down to design our next set of internal apps. I would like
to approach this in a way that would allow me to break logical parts of
the application that handle specific tasks into modules. For example,
assuming we have 4 main tasks to accomplish:
- Printing
- Editing
- Viewing
- Inventory Management

Each of those tasks would have an associated UI(User Control) with all
relevant UI controls, for example printing would have printing options,
printer names, etc.

My motivation for wanting to make these separate is that different
combinations of these modules need to be rolled together into
applications. For example, at my desk, I would want an application that
would support all 4 tasks, while in the shop, they only need Printing,
Inventory and Viewing. Someone else might only need Viewing.

Rather than develop all modules under the same project and build separate
binaries with various modules enabled or disabled, I would rather have a
project for each module, then a project for each combination of modules
and include the modules that I need.

I suppose this is actually a sort of plug-in architecture that I'm
looking for. I haven't ever done anything like this and am interested in
how most of you would approach this? Anyone know of any good articles or
books on the subject?

Thanks for reading,
Steve


Jan 24 '06 #3
One place to look at for a "big" example of this type of thing is the
Eclipse project.

http://www.eclipse.org/

It is an "everything but nothing at all" type of framework. It provides the
"general application" and you provide the "components that do something". I
have not used it but have dealt with others that have and it seems to work
for them.

Might be to big of a thing for your project but at least it can give you
some ideas maybe?
"Steve" <ss*@sss.com> wrote in message
news:%2******** *******@TK2MSFT NGP12.phx.gbl.. .
Very nice, that is a great overview!
I too had thought of the single "host" application that would host the add
ons and make them availablew based on the current users role.

I printed your message, it's a nice overview, I'll read it a couple times,
thanks for the post.

Have a good one,
Steve
"C.C. (aka Me)" <me@home.com> wrote in message
news:ts******** *************** *******@comcast .com...
Well the first thing you should look into is the notion of Add-Ons in
general (maybe do a web search for it). This will help you understand
what AddOn's are and different ways of implementing them.

Next, take a look at Interfaces because that is a core part of Add-On
implmentations. You will need a common set of methods (aka an Interface)
that can be used to access the Add-On.

Here is an example of an Interface and a way that you could use it in
your application.

+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++
interface IAddOn
{
String Name(); //Returns a human readable name of this AddOn like
"Printing"
String Description(); //Returns a brief description like "Allows
Printing of internal documents"
bool Startup(); //Performs any init/startup code that is needed and
returns true/false as a success result.
bool Shutdown(); //Performs any shutdown code that is needed and
returns true/false as a result.
void Show(); //Informs the AddOn that it should display itself.
void Hide(); //Informs the AddOn that it should hide itself.
void Execute(String cmd); //Tells the AddOn to execute the given
command. cmd could be an xml string or anything?
}

Now if you are going to have a standard application that these AddOns
will be part of then maybe you could use a menu system to show the
available "options" that are intalled. The menu system could be an actual
menu or maybe just different buttons on a form that are clicked on.

The application could look at the files in a specific directory (maybe
\AddOns) and use Reflection to load and create an instance of each of the
files contained in it. Each file (assembly) would have a class that is
derived from the IAddOn interface so you could determine what class you
should instantiate. Or maybe you have a config file that contains a list
of assembly files and class names that should be loaded.

After loading each of the AddOns the application could call Startup() on
each one so that they could do any initializing they needed.

Using the Name() member of the IAddOn interface you could dynamically add
a menu item that the operator could select in order to activate the
AddOn.

When the operator selected an AddOn from the menu you could call the
Show() method or maybe the Execute() method to have the AddOn peform it's
task.

When the application is closed down you would want to call Shutdown() so
that the AddOn's could do any uninit type of stuff they needed like
closing files, etc.
+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++

The nice thing about this type of setup is that you could have different
types of AddOn's. Maybe you have an interface used for user selectable
options, and another interface for background utilities.

Or, maybe you want to implement some sort of secutity mechanism. The
Interface could have a method that takes a username and returns true if
it is allowed to use the AddOn. This way you could have one application
with all the AddOns available but the user logs and only sees what they
are allowed to use.

Kind of a brief overview of this type of development but maybe it can
give you some insite?
"Steve" <ss*@sss.com> wrote in message
news:ev******** *******@TK2MSFT NGP09.phx.gbl.. .
Hi,

I am sitting down to design our next set of internal apps. I would like
to approach this in a way that would allow me to break logical parts of
the application that handle specific tasks into modules. For example,
assuming we have 4 main tasks to accomplish:
- Printing
- Editing
- Viewing
- Inventory Management

Each of those tasks would have an associated UI(User Control) with all
relevant UI controls, for example printing would have printing options,
printer names, etc.

My motivation for wanting to make these separate is that different
combinations of these modules need to be rolled together into
applications. For example, at my desk, I would want an application that
would support all 4 tasks, while in the shop, they only need Printing,
Inventory and Viewing. Someone else might only need Viewing.

Rather than develop all modules under the same project and build
separate binaries with various modules enabled or disabled, I would
rather have a project for each module, then a project for each
combination of modules and include the modules that I need.

I suppose this is actually a sort of plug-in architecture that I'm
looking for. I haven't ever done anything like this and am interested
in how most of you would approach this? Anyone know of any good
articles or books on the subject?

Thanks for reading,
Steve



Jan 24 '06 #4
Yeah, Eclipse is overkill for what I want.

I wonder how I can debug my Add-Ons outside of the host? To launch them in
the debugger, they would need to be WinForms application, but I can't
imagine it would be proper for a "Host" winforms app to host another
winforms app. Does that make sense?

I google for AddOn led me to this article:
http://msdn.microsoft.com/msdnmag/is...10/plug%2Dins/

I haven't read it yet, just browsed but it sounds like a good place to start
for me.
"C.C. (aka Me)" <me@home.com> wrote in messag e
news:cd******** *************** *******@comcast .com...
One place to look at for a "big" example of this type of thing is the
Eclipse project.

http://www.eclipse.org/

It is an "everything but nothing at all" type of framework. It provides
the "general application" and you provide the "components that do
something". I have not used it but have dealt with others that have and it
seems to work for them.

Might be to big of a thing for your project but at least it can give you
some ideas maybe?
"Steve" <ss*@sss.com> wrote in message
news:%2******** *******@TK2MSFT NGP12.phx.gbl.. .
Very nice, that is a great overview!
I too had thought of the single "host" application that would host the
add ons and make them availablew based on the current users role.

I printed your message, it's a nice overview, I'll read it a couple
times, thanks for the post.

Have a good one,
Steve
"C.C. (aka Me)" <me@home.com> wrote in message
news:ts******** *************** *******@comcast .com...
Well the first thing you should look into is the notion of Add-Ons in
general (maybe do a web search for it). This will help you understand
what AddOn's are and different ways of implementing them.

Next, take a look at Interfaces because that is a core part of Add-On
implmentations. You will need a common set of methods (aka an Interface)
that can be used to access the Add-On.

Here is an example of an Interface and a way that you could use it in
your application.

+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++
interface IAddOn
{
String Name(); //Returns a human readable name of this AddOn like
"Printing"
String Description(); //Returns a brief description like "Allows
Printing of internal documents"
bool Startup(); //Performs any init/startup code that is needed and
returns true/false as a success result.
bool Shutdown(); //Performs any shutdown code that is needed and
returns true/false as a result.
void Show(); //Informs the AddOn that it should display itself.
void Hide(); //Informs the AddOn that it should hide itself.
void Execute(String cmd); //Tells the AddOn to execute the given
command. cmd could be an xml string or anything?
}

Now if you are going to have a standard application that these AddOns
will be part of then maybe you could use a menu system to show the
available "options" that are intalled. The menu system could be an
actual menu or maybe just different buttons on a form that are clicked
on.

The application could look at the files in a specific directory (maybe
\AddOns) and use Reflection to load and create an instance of each of
the files contained in it. Each file (assembly) would have a class that
is derived from the IAddOn interface so you could determine what class
you should instantiate. Or maybe you have a config file that contains a
list of assembly files and class names that should be loaded.

After loading each of the AddOns the application could call Startup() on
each one so that they could do any initializing they needed.

Using the Name() member of the IAddOn interface you could dynamically
add a menu item that the operator could select in order to activate the
AddOn.

When the operator selected an AddOn from the menu you could call the
Show() method or maybe the Execute() method to have the AddOn peform
it's task.

When the application is closed down you would want to call Shutdown() so
that the AddOn's could do any uninit type of stuff they needed like
closing files, etc.
+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++

The nice thing about this type of setup is that you could have different
types of AddOn's. Maybe you have an interface used for user selectable
options, and another interface for background utilities.

Or, maybe you want to implement some sort of secutity mechanism. The
Interface could have a method that takes a username and returns true if
it is allowed to use the AddOn. This way you could have one application
with all the AddOns available but the user logs and only sees what they
are allowed to use.

Kind of a brief overview of this type of development but maybe it can
give you some insite?
"Steve" <ss*@sss.com> wrote in message
news:ev******** *******@TK2MSFT NGP09.phx.gbl.. .
Hi,

I am sitting down to design our next set of internal apps. I would
like to approach this in a way that would allow me to break logical
parts of the application that handle specific tasks into modules. For
example, assuming we have 4 main tasks to accomplish:
- Printing
- Editing
- Viewing
- Inventory Management

Each of those tasks would have an associated UI(User Control) with all
relevant UI controls, for example printing would have printing options,
printer names, etc.

My motivation for wanting to make these separate is that different
combinations of these modules need to be rolled together into
applications. For example, at my desk, I would want an application that
would support all 4 tasks, while in the shop, they only need Printing,
Inventory and Viewing. Someone else might only need Viewing.

Rather than develop all modules under the same project and build
separate binaries with various modules enabled or disabled, I would
rather have a project for each module, then a project for each
combination of modules and include the modules that I need.

I suppose this is actually a sort of plug-in architecture that I'm
looking for. I haven't ever done anything like this and am interested
in how most of you would approach this? Anyone know of any good
articles or books on the subject?

Thanks for reading,
Steve



Jan 24 '06 #5
You should still be able to debug them.

Say you have the following projects:

MainApp (WinForm application project)
Comp1 (Class Library)
Comp2 (Class Library)

Now you can debug the Control Libraries if you add them to your MainApp
project. You can dynamically load them still from a config file or whatever,
but VS should see that you have the source code and allow you to debug them.

So you could debug them from within the normal application that your users
interact with.

--
~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~
Charles Cox
VC/VB/C# Developer
~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~

"Steve" <ss*@sss.com> wrote in message
news:ep******** ******@TK2MSFTN GP10.phx.gbl...
Yeah, Eclipse is overkill for what I want.

I wonder how I can debug my Add-Ons outside of the host? To launch them
in the debugger, they would need to be WinForms application, but I can't
imagine it would be proper for a "Host" winforms app to host another
winforms app. Does that make sense?

I google for AddOn led me to this article:
http://msdn.microsoft.com/msdnmag/is...10/plug%2Dins/

I haven't read it yet, just browsed but it sounds like a good place to
start for me.
"C.C. (aka Me)" <me@home.com> wrote in messag e
news:cd******** *************** *******@comcast .com...
One place to look at for a "big" example of this type of thing is the
Eclipse project.

http://www.eclipse.org/

It is an "everything but nothing at all" type of framework. It provides
the "general application" and you provide the "components that do
something". I have not used it but have dealt with others that have and
it seems to work for them.

Might be to big of a thing for your project but at least it can give you
some ideas maybe?
"Steve" <ss*@sss.com> wrote in message
news:%2******** *******@TK2MSFT NGP12.phx.gbl.. .
Very nice, that is a great overview!
I too had thought of the single "host" application that would host the
add ons and make them availablew based on the current users role.

I printed your message, it's a nice overview, I'll read it a couple
times, thanks for the post.

Have a good one,
Steve
"C.C. (aka Me)" <me@home.com> wrote in message
news:ts******** *************** *******@comcast .com...
Well the first thing you should look into is the notion of Add-Ons in
general (maybe do a web search for it). This will help you understand
what AddOn's are and different ways of implementing them.

Next, take a look at Interfaces because that is a core part of Add-On
implmentations. You will need a common set of methods (aka an
Interface) that can be used to access the Add-On.

Here is an example of an Interface and a way that you could use it in
your application.

+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++
interface IAddOn
{
String Name(); //Returns a human readable name of this AddOn like
"Printing"
String Description(); //Returns a brief description like "Allows
Printing of internal documents"
bool Startup(); //Performs any init/startup code that is needed and
returns true/false as a success result.
bool Shutdown(); //Performs any shutdown code that is needed and
returns true/false as a result.
void Show(); //Informs the AddOn that it should display itself.
void Hide(); //Informs the AddOn that it should hide itself.
void Execute(String cmd); //Tells the AddOn to execute the given
command. cmd could be an xml string or anything?
}

Now if you are going to have a standard application that these AddOns
will be part of then maybe you could use a menu system to show the
available "options" that are intalled. The menu system could be an
actual menu or maybe just different buttons on a form that are clicked
on.

The application could look at the files in a specific directory (maybe
\AddOns) and use Reflection to load and create an instance of each of
the files contained in it. Each file (assembly) would have a class that
is derived from the IAddOn interface so you could determine what class
you should instantiate. Or maybe you have a config file that contains
a list of assembly files and class names that should be loaded.

After loading each of the AddOns the application could call Startup()
on each one so that they could do any initializing they needed.

Using the Name() member of the IAddOn interface you could dynamically
add a menu item that the operator could select in order to activate the
AddOn.

When the operator selected an AddOn from the menu you could call the
Show() method or maybe the Execute() method to have the AddOn peform
it's task.

When the application is closed down you would want to call Shutdown()
so that the AddOn's could do any uninit type of stuff they needed like
closing files, etc.
+++++++++++++++ +++++++++++++++ +++++++++++++++ +++++++++++++++ ++++++

The nice thing about this type of setup is that you could have
different types of AddOn's. Maybe you have an interface used for user
selectable options, and another interface for background utilities.

Or, maybe you want to implement some sort of secutity mechanism. The
Interface could have a method that takes a username and returns true if
it is allowed to use the AddOn. This way you could have one application
with all the AddOns available but the user logs and only sees what they
are allowed to use.

Kind of a brief overview of this type of development but maybe it can
give you some insite?
"Steve" <ss*@sss.com> wrote in message
news:ev******** *******@TK2MSFT NGP09.phx.gbl.. .
> Hi,
>
> I am sitting down to design our next set of internal apps. I would
> like to approach this in a way that would allow me to break logical
> parts of the application that handle specific tasks into modules. For
> example, assuming we have 4 main tasks to accomplish:
> - Printing
> - Editing
> - Viewing
> - Inventory Management
>
> Each of those tasks would have an associated UI(User Control) with all
> relevant UI controls, for example printing would have printing
> options, printer names, etc.
>
> My motivation for wanting to make these separate is that different
> combinations of these modules need to be rolled together into
> applications. For example, at my desk, I would want an application
> that would support all 4 tasks, while in the shop, they only need
> Printing, Inventory and Viewing. Someone else might only need Viewing.
>
> Rather than develop all modules under the same project and build
> separate binaries with various modules enabled or disabled, I would
> rather have a project for each module, then a project for each
> combination of modules and include the modules that I need.
>
> I suppose this is actually a sort of plug-in architecture that I'm
> looking for. I haven't ever done anything like this and am interested
> in how most of you would approach this? Anyone know of any good
> articles or books on the subject?
>
> Thanks for reading,
> Steve
>



Jan 24 '06 #6

This thread has been closed and replies have been disabled. Please start a new discussion.

Similar topics

7
2922
by: James | last post by:
I am currently working on a PHP based website that needs to be able to draw from Oracle, MS SQL Server, MySQL and given time and demand other RDBMS. I took a lot of time and care creating a flexible and solid wrapper and am deep into coding. The only problem is a noticed VARCHAR fields being drawn from SQL Server 2000 are being truncated to...
75
6122
by: Howard Nease | last post by:
Hello, everyone. I would appreciate any advice that someone could give me on my future career path. Here is my situation: I am a bright Junior in a very well-respected private high school, taking almost all AP and accelerated classes. I am HIGHLY interested in technology, more specifically the field of Computer Science and software...
0
1646
by: Peter Rohleder | last post by:
Hi, I have a few simple questions in order to use modularized xhtml and getting it to work. A simple example may make this obviouse: Lets say we want to create a simple xml-file to reflect a faq-structure.
6
1125
by: Eddie Paz | last post by:
I have a program written in MFC. I'm at the point where I need to start working on the major release (tons of new features needed - new fiscal year budget and all-). I'm looking into vc++.net since I figure that I need to buy the bullet already and get into the .net thing. I'm concerned, however, with the syntax change in Whidbey. I feel...
1
9603
by: David Van D | last post by:
Hi there, A few weeks until I begin my journey towards a degree in Computer Science at Canterbury University in New Zealand, Anyway the course tutors are going to be teaching us JAVA wth bluej and I was wondering if anyone here would be able to give me some tips for young players such as myself, for learning the language. Is this the...
4
1442
by: MPA | last post by:
Hi, We are a small company with experience in client-server apps with PowerBuilder and most major databases. We have no internet experience. We are now looking into slimming our main application, rewriting it with DOT.NET and making it accessible for Internet browsers. Our app constists of hierarchical tree (with usually several hundred...
232
13115
by: robert maas, see http://tinyurl.com/uh3t | last post by:
I'm working on examples of programming in several languages, all (except PHP) running under CGI so that I can show both the source files and the actually running of the examples online. The first set of examples, after decoding the HTML FORM contents, merely verifies the text within a field to make sure it is a valid representation of an...
2
1279
by: =?Utf-8?B?QmlnU2Ft?= | last post by:
I hope I'm in the correct forum. Please advise if I need to move this question. I've a lead developer who insists on developing with classic ASP & VB6. He & his team have created an impressive set of web pages, relying to a great extent on COM+ components. Normally I want to stay out of other people's hair, especially regarding how they do...
23
1208
by: Kahuna | last post by:
Hi Folks I've been developing in MSA97 since it first hit the streets and its been fantastic for what we needed. We have a number of Apps out there all in runtime and all doing sterling work! Time to move on though and we have been pulled from pillar to post (old English expression) looking at Java, .NET and a host of RAD's that build in...
0
7851
Oralloy
by: Oralloy | last post by:
Hello folks, I am unable to find appropriate documentation on the type promotion of bit-fields when using the generalised comparison operator "<=>". The problem is that using the GNU compilers, it seems that the internal comparison operator "<=>" tries to promote arguments from unsigned to signed. This is as boiled down as I can make it. ...
0
8072
jinu1996
by: jinu1996 | last post by:
In today's digital age, having a compelling online presence is paramount for businesses aiming to thrive in a competitive landscape. At the heart of this digital strategy lies an intricately woven tapestry of website design and digital marketing. It's not merely about having a website; it's about crafting an immersive digital experience that...
0
7924
tracyyun
by: tracyyun | last post by:
Dear forum friends, With the development of smart home technology, a variety of wireless communication protocols have appeared on the market, such as Zigbee, Z-Wave, Wi-Fi, Bluetooth, etc. Each protocol has its own unique characteristics and advantages, but as a user who is planning to build a smart home system, I am a bit confused by the...
1
5462
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 1 May 2024 starting at 18:00 UK time (6PM UTC+1) and finishing by 19:30 (7.30PM). In this session, we are pleased to welcome a new presenter, Adolph Dupré who will be discussing some powerful techniques for using class modules. He will explain when you may want to use classes...
0
5177
by: conductexam | last post by:
I have .net C# application in which I am extracting data from word file and save it in database particularly. To store word all data as it is I am converting the whole word file firstly in HTML and then checking html paragraph one by one. At the time of converting from word file to html my equations which are in the word document file was convert...
0
3609
by: TSSRALBI | last post by:
Hello I'm a network technician in training and I need your help. I am currently learning how to create and manage the different types of VPNs and I have a question about LAN-to-LAN VPNs. The last exercise I practiced was to create a LAN-to-LAN VPN between two Pfsense firewalls, by using IPSEC protocols. I succeeded, with both firewalls in...
1
2055
by: 6302768590 | last post by:
Hai team i want code for transfer the data from one system to another through IP address by using C# our system has to for every 5mins then we have to update the data what the data is updated we have to send another system
1
1171
muto222
by: muto222 | last post by:
How can i add a mobile payment intergratation into php mysql website.
0
884
bsmnconsultancy
by: bsmnconsultancy | last post by:
In today's digital era, a well-designed website is crucial for businesses looking to succeed. Whether you're a small business owner or a large corporation in Toronto, having a strong online presence can significantly impact your brand's success. BSMN Consultancy, a leader in Website Development in Toronto offers valuable insights into creating...

By using Bytes.com and it's services, you agree to our Privacy Policy and Terms of Use.

To disable or enable advertisements and analytics tracking please visit the manage ads & tracking page.