473,322 Members | 1,425 Online
Bytes | Software Development & Data Engineering Community
Post Job

Home Posts Topics Members FAQ

Join Bytes to post your question to a community of 473,322 software developers and data experts.

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 1683
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***************@TK2MSFTNGP09.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***************@TK2MSFTNGP09.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***************@TK2MSFTNGP12.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***************@TK2MSFTNGP09.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***************@TK2MSFTNGP12.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***************@TK2MSFTNGP09.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**************@TK2MSFTNGP10.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***************@TK2MSFTNGP12.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***************@TK2MSFTNGP09.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
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...
75
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...
0
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...
6
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...
1
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...
4
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,...
232
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...
2
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...
23
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! ...
0
by: ryjfgjl | last post by:
ExcelToDatabase: batch import excel into database automatically...
0
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
1
isladogs
by: isladogs | last post by:
The next Access Europe meeting will be on Wednesday 6 Mar 2024 starting at 18:00 UK time (6PM UTC) and finishing at about 19:15 (7.15PM). In this month's session, we are pleased to welcome back...
0
by: jfyes | last post by:
As a hardware engineer, after seeing that CEIWEI recently released a new tool for Modbus RTU Over TCP/UDP filtering and monitoring, I actively went to its official website to take a look. It turned...
1
by: PapaRatzi | last post by:
Hello, I am teaching myself MS Access forms design and Visual Basic. I've created a table to capture a list of Top 30 singles and forms to capture new entries. The final step is a form (unbound)...
1
by: Defcon1945 | last post by:
I'm trying to learn Python using Pycharm but import shutil doesn't work
1
by: Shællîpôpï 09 | last post by:
If u are using a keypad phone, how do u turn on JavaScript, to access features like WhatsApp, Facebook, Instagram....
0
by: Faith0G | last post by:
I am starting a new it consulting business and it's been a while since I setup a new website. Is wordpress still the best web based software for hosting a 5 page website? The webpages will be...
0
isladogs
by: isladogs | last post by:
The next Access Europe User Group meeting will be on Wednesday 3 Apr 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 former...

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.