tcl-tdbc — Discussion of TDBC - Tcl DataBase Connectivity - TIP #308

Re: [Tcl-tdbc] [TCLCORE] Remove MySQL <5.1 support?

[<st...@di...>]

Hi Kevin,

I would turn the question around and phrase it this way:  is there any justification for continuing support of MySQL client libraries prior to version 5.1?

And if there was, I would suggest you consider doing it on a commercial basis.

-- Steve
On 18 Sep 2022, 3:34 AM +0800, Kevin Kenny <kev...@gm...>, wrote:
> Team,
>
> I recently fixed a critical bug in tdbc::mysql that had its roots in the gymnastics that we go through to support the API incompatibilities with MySQL client libraries prior to version 5.1.
>
> Since 5.0 went end-of-life about a decade ago, what would people think about removing that stuff altogether and simply using the API from 5.1 and beyond (including all extant versions of MariaDB)?
>
> --
> 73 de ke9tv/2, Kevin
> _______________________________________________
> Tcl-Core mailing list
> Tcl...@li...
> https://lists.sourceforge.net/lists/listinfo/tcl-core

[Tcl-tdbc] Remove MySQL <5.1 support?

[Kevin K. <kev...@gm...>]

Team,

I recently fixed a critical bug in tdbc::mysql that had its roots in the
gymnastics that we go through to support the API incompatibilities with
MySQL client libraries prior to version 5.1.

Since 5.0 went end-of-life about a decade ago, what would people think
about removing that stuff altogether and simply using the API from 5.1 and
beyond (including all extant versions of MariaDB)?

-- 
73 de ke9tv/2, Kevin

[Tcl-tdbc] tdbc::sqlite3, Sqlite amalgamation >= 3.14, and trace_v2

[Trevor D. (Twylite) <tw...@cr...>]

Hi,

I'm in the process of upgrading Sqlite3 in an application with an older 
(Tcl 8.6.2 circa 2014) runtime, and I've run into an issue with 
tdbc::sqlite3. What I'm seeing is that `nextlist` always gives an empty row.

Digging through the source (sqlite3-1.0.1.tm) it looks like the problem 
is that `${-db} trace [namespace code {my RecordStatement}]` is not 
firing, so `-needcolumns` never gets set, `columns` never gets added to 
`-results`, and eventually `nextlist` has no columns to iterate over so 
it returns an empty list. The root cause appears to be that shortly 
after sqlite_trace_v2() was added in Sqlite 3.14, the DbTraceHandler 
used by the old sqlite_trace() was marked deprecated (see 
https://sqlite.org/src/annotate?filename=src/tclsqlite.c&checkin=trunk), 
and thus `${-db} trace` is no longer supported by the Sqlite 
Amalgamation. According to 
https://core.tcl-lang.org/tdbcsqlite3/finfo?name=library/tdbcsqlite3.tcl 
the latest tdbc::sqlite3 still uses `${-db} trace` instead of 
`trace_v2`. I don't see any related tickets at 
https://core.tcl-lang.org/tdbcsqlite3/ticket.

Have I missed something here, or is everyone (who is using 
tdbc::sqlite3) using it with an older Sqlite (< 3.14) or a custom (not 
Amalgamation) build?

Kind regards,
Trevor

[Tcl-tdbc] Announcement & Call for Speakers (The SQLite & Tcl Conf 2021)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

# The SQLite & Tcl Conference

__Wednesday, November 17, 2021__

The 2nd annual SQLite & Tcl virtual conference will be held on Wednesday, November 17.
The virtual event will feature a combination of curated talks and work in progress talks (WIPs).

[Registration is open](https://www.eventbrite.com/e/the-sqlite-tcl-conference-st-2021-registration-168185004877)!

Please visit the [SQLite & TCL conference](https://conf.tcl-lang.org/) home page to stay informed.

# Call for Speakers

We've made it easier to contribute by asking for shorter, less formal
talks rather than requiring formal papers.

  - Have you done interesting work that you would like to share?

  - How about a cool idea that's not yet baked or just in the
    prototype stage but seems like something others would be
    interested in? We are particularly interested in new ideas, to
    hear about novel solutions to problems you've faced, or to see
    your work in progress.

## To submit your talk:

Please visit the [call for speakers page](https://conf.tcl-lang.org/callforspeakers/)
for instructions.

As a token of our appreciation, each speaker will be gifted with a
video conferencing light kit to use while presenting.

The call for speakers for S&T 2021 ends on __October 4, 2021 at 11:59 PM CT__.

__Important dates:__

  - October 4 - Call for speakers for S&T 2021 ends at 11:59 PM CT

  - October 8 - We will start notifying speakers with their status of
    their submission and scheduled talk.

  - October 18 - Agenda for S&T 2021 Announced

  - November 17 - S&T 2021 held digitally online  

[Tcl-tdbc] Call For Presentations - SQLite & Tcl 2020 (Virtual Event)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

SQLite & Tcl 2020 (Virtual Event)
https://www.tcl-lang.org/community/tcl2020/

This year the Tcl conference of past years has been re-imaged as a
virtual event titled __S&T 2020 (SQLite & TCL)__, to be held
__Tuesday, November 10 from 10am to 3pm CDT__. The exact timing is
subject to change depending on the amount of people who sign up to
present a WIP (work in progress) presentation.

The event will be hosted through Zoom.
To register please go to the
[event details on eventbrite](https://www.eventbrite.com/e/st-2020-tickets-122293825123).

Given the Covid-19 virus and all the disruption it's causing, we
thought rather than requiring people to put all the work and time into
creating a full-fledged academic paper, we'd instead make it easier on
contributors by asking for shorter, less formal talks.

Have you done interesting work that you would like to share?

How about a cool idea that's not yet baked or just in the prototype
stage but seems like something others would be interested in?

The SQLite & TCL audience would like to hear about it, and can provide
valuable discussion and feedback. We are particularly interested in
new ideas, to hear about novel solutions to problems you've faced, or
to see your work in progress.

To schedule your talk, please send email to
[vio...@fl...](mailto:vio...@fl...)

Sincerly.

[Tcl-tdbc] tdbc::mysql execute problem

[Alexander S. <a.s...@gm...>]

My short script ends in "Can't create more than max_prepared_stmt_count statements (current value: 16382)".
I don't know what the mistake is. What is not closed, that it comes to the error?

MySQL:

CREATE SCHEMA `testdb`;
CREATE TABLE testdb.testtable (num INT NOT NULL, txt VARCHAR(45) NULL, PRIMARY KEY (num)) ENGINE = MyISAM;


Tcl:

package require tdbc::mysql
set db [tdbc::mysql::connection new -user root -passwd {} -host localhost -db testdb]
set repl [$db prepare {replace into testtable (num, txt) values (:num, :txt)}]

for {set n 0} {$n < 16400} {incr n} {
 dict set data num $n
 dict set data txt $n
 set result [$repl execute $data]
 $result destroy
}

$db destroy


Error:

Can't create more than max_prepared_stmt_count statements (current value: 16382)
   while executing
"::oo::Obj17::Stmt::1 resultSetCreate ::oo::Obj18::ResultSet::16383 ::oo::Obj17::Stmt::1 {num 16382 txt 16382}"
   ("uplevel" body line 1)
   invoked from within
"uplevel 1  [list  [self] resultSetCreate  [namespace current]::ResultSet::[incr resultSetSeq]  [self] {*}$args]"
   (class "::tdbc::statement" method "execute" line 2)
   invoked from within
"$repl execute $data"
   ("for" body line 4)
   invoked from within
"for {set n 0} {$n < 16400} {incr n} {
 dict set data num $n
 dict set data txt $n
 set result [$repl execute $data]
 $result close
}"
   (file "replace.tcl" line 11)


Regards,
Alex

[Tcl-tdbc] resultset metadata

[Luis E. C. <qua...@gm...>]

Hello

I'm automating data extraction from a database to
invoke an existing functionality.

The problem I have is that the library that I should call has calls like this:

int addIntField (int position, int value);
int addFloatField (int position, duble value);
int addStringField (int position, const char * value);
...

Depending on the data type returned by the database, so is the call.

I am using tdbc :: odbc for database connection like this:


package require tdbc
package require tdbc::odbc

tdbc::odbc::connection create db "DSN=$DSN" -readonly 1

set query {select e.empno, e.ename, e.deptno, d.dname  from emp as e
inner join dept as d on d.deptno = e.deptno}

set stmt [db prepare $query]
set resultset [$stmt execute]

I have reviewed the documentation in
 https://www.tcl.tk/man/tcl8.6/TdbcodbcCmd/tdbc_odbc.htm
unsuccessfully.

Is there any way to get not only the names, but also the data types of
the $resultset?

I'm using Tcl 8.6, tdbc 1.1.0 and tdbc::odbc 1.1.0 on Debian Buster.

Regards,


Luis E. Castro

Re: [Tcl-tdbc] Connection pooling for TDBC

[Cyan O. <cya...@gm...>]

On Tue, Feb 11, 2020 at 6:04 PM Kevin Kenny <kev...@gm...> wrote:

> On Tue, Feb 11, 2020 at 9:32 AM Cyan Ogilvie <cya...@gm...>
> wrote:
> > I've put together a thread-aware connection pooling mechanism for TDBC
> and would like to know if there is interest in merging the changes into
> TDBC itself, and if so, what the process for that would be.
>
> This sounds like a terrific idea. At this point, the process is quite
> informal - we publish 'Informational' TIP's for major API changes, but
> that's about it.
>
> I'm presuming that the 'thread-aware'-ness is at the driver (and
> connection attachment) level? At the higher levels, there are quite a
> lot of Tcl_Obj's about, and the logic is mostly designed as
> 'multi-interp-safe and thread-oblivious'.
>

Yes, mainly - it's the driver's responsibility to ensure that the detach
method and the relevant portions of the constructor's -attach handling are
thread safe, and that the handle returned by detach can use attached from
another thread, but that's about it.  The core connection pooling machinery
that's currently in tdbc.tcl is very heavily involved in all the thread
details, but exclusively at a Tcl level using the Thread package, and tsv
variables to hold the detached handles for the pools.  To avoid the issue
of moving Tcl_Objs between threads the current design allows moving only
the minimum state (the native database connection handle), although it
would be up to each driver to implement detach and -attach in any way that
makes sense it it.  My pure-Tcl postgres driver for instance would just
thread::detach the socket chan and hand the chan name back.


> > The design looks like this:
> >
> > To retrieve a handle from the pool:
> >
> >     tdbc::${driver}::connection create db -host localhost -db foo
> >
> > becomes:
> >
> >     tdbc::pool $driver create db -host localhost -db foo
> >
> > When the thread is finished with the connection, it instead of
> >
> >     db destroy   (or db close)
> >
> > it would do:
> >
> >     db release
> >
> > which destroys db and any statements and resultsets associated with it,
> rolls back the transaction if one is open, and parks the database handle
> for the connection in a pool of detached connections.  The next call to
> tdbc::pool that matches the driver and connection arguments will retrieve
> the most recently released connection instead of creating a new connection
> (making it more of a stack than a pool).  This is done to keep the busy set
> of handles to a minimum and allow the idle ones to time out (2 minutes) and
> be closed.  This way the pool will grow as needed with a load spike and
> then shrink back down once the spike has passed and idle detached
> connections time out.
>
> Nice, clean, simple.  I like it a lot.
>
> I wonder if we could actually override the object destruction in some
> way, or else go through a wrapper object, so that the user of the
> connection would use 'db destroy' or 'rename db {}' in either case. I
> can easily see myself forgetting which pathway to use when finalizing
> a connection!


Very tempting, and I've put comments in the code in the relevant places to
explore this, but I shied away from it for now because it would need a
really-really-destroy method to make the system work - otherwise
connections will never really die, just return to the pool.  The background
checks on the pool need to be able to destroy objects to finalise the
underlying database connection (in the case of an idle timeout or a
connection error).

It isn't an error to call close or destroy (or rename to {}) on a handle
retrieved from the pool, it just explicitly closes that connection, which
may be deliberate in situations such as getting an exception on a query
that indicates that the connection is in a bad state (Aurora Serverless
MySQL from Amazon will kill long-running transactions if it wants to scale
the cluster and couldn't find a safe scaling point, and is configured to do
this.  In this case the application gets a mysql 1080 exception and that
connection is dead).  There isn't any accounting related to a handle that
is issued from the pool to clean up, the "release" method (added by the
pool machinery when it served up the connection) contains the logic to put
the connection back into the pool it came from, but that's all there is.  I
could also imagine a higher-level connection pool manager that enforces
things like a maximum number of times to reuse a handle, which would need
to be able to explicitly destroy a connection rather than releasing it).
So both are valid, and currently under the application's control, but I
agree that it would be nice to have the default behaviour for a connection
served from the pool bt to return to the pool under the normal close or
destroy, I just couldn't immediately think of a clean way to do that with
the other requirements.

I'm copying Donal and Sean on this so as to get suggestions from the
> TclOO guru and the architecture astronaut. I could certainly work up
> wrapping logic that would work, but I'm guessing that they will point
> out subtleties that I will miss.
>
> > When tdbc::pool issues a connection from the pool (creating a fresh one
> if needed), and he pool is empty, it initiates a new connection in a
> background thread and adds it to the pool, priming it for the next
> request.  The intent of the pooling mechanism is primarily to hide the
> connection setup latency from short-lived users of the db handles, as is
> typical of web server usage patterns.
> >
> > Time to get a handle from the pool on my test machine is between 80 and
> 300 microseconds, vs 7000 to 18000 microseconds without the pool (postgres
> or mysql database on localhost).
>
> Sweet!
>
> Now I'm thinking. Having some sort of wrapper object would be really
> nice, because another potential performance win would be to allow a
> pooled connection to retain its prepared statements. That would be
> trickier, since the Statement object isn't thread-safe at present, but
> most of the stuff in it could be transferred among threads without too
> much baggage. I _think_. No time right now to delve into it, I'm
> afraid.
>

Yes, freezing and thawing statements with the connections would be nice,
but would lead to some complexity in the connection setup process (the
application code getting the handle doesn't know whether the connection
it's received is a new one or previously detached, and so whether there are
associated statements).  Some sort of wrapper class for the connections
that are handed out by tdbc::pool could probably address this in a clean
way, but I don't have all the details in sight yet).


> > The detached connections in the pool are periodically checked (every 20
> seconds), and those that are no longer connected to the server or which are
> older than 2 minutes are closed and removed from the pool.  If the pool
> size goes to 0 as a result, a new connection is created to prime the pool.
>
> Does this create a blip every 20 seconds on an idle application, where
> a never-used connection is closed and immediately reopened? Is this
> intentional, perhaps to make sure that the server connection is still
> live, or am I misunderstanding what's up here?
>

It does, but the impact is minimal.  An idle application will quickly (<=
140 seconds currently) scale down to a pool with a single detached
connection in it.  The background poll is very lightweight, essentially:

foreach pool [tsv::array names tdbcPools] {
    set driver  [lindex $pool 0]
    package require tdbc::$driver
    set now    [clock microseconds]
    tsv::lock tdbcPools {
        set detachedhandles     [tsv::get tdbcPools $pool]
        tsv::set tdbcPools $pool {}
    }
    foreach detachedhandle $detachedhandles {
        lassign $detachedhandle handle lastUsed
        try {
            tdbc::${driver}::connection new -attach $handle
        } on ok obj {
            if {($now - $lastUsed) / 1e6 > $timeout || ![$obj connected]} {
                $obj destroy
            } else {
                # Still valid - put it back
                tsv::lappend tdbcPools $pool [list [$obj detach] $lastUsed]
            }
        } on error {errmsg options} {}
    }

    if {[tsv::llength tdbcPools $pool] == 0} {
        prime $pool
    }
}

So, with the current configuration, an idle application will have a
background thread wake up every 20 seconds, pop a single handle from the
tsv, wrap it in a connection instance, call its connected method (usually a
round trip to the server) and lappend it back onto the tsv.  Every 120
seconds or so the connection will hit the idle timeout and be closed and a
new one opened to the server.  It's wasteful, but implied by the goal of
the connection pool to hide the latency of creating new connections - it
wants to have an already open and likely valid (no guarantees) connection
to hand to the next caller.  Many database servers (like Amazon's Aurora
Serverless versions of MySQL and Postgres) will drop idle connections, so
the periodic check is necessary to avoid always running into that case when
resuming activity after a pause.  There is a tdbc::poolDestroy $pool
command to unwind this if the pool is not going to be needed again (soon)
and the application wants to avoid this overhead.  On a related point I
would probably want to tweak things so that no background thread is spawned
until the first call of tdbc::pool by an application, so that it doesn't
pay the cost of the thread unless it actually uses the pool mechanism.


> > In order to support connection pooling, a TDBC driver needs 3 things:
> >
> > - Support construction with a single parameter "-attach $handle", which
> should create a new connection instance and attach it to the previously
> detached database handle indicated by $handle:
> >
> >     tdbc::${driver}::connection new -attach $handle
> >
> > - A new method "detach" that destroys the connection and returns a
> handle that can be used in the future to reattach to this database
> connection (possibly from another thread):
> >
> >     $connection detach
> >
> > - A new method "connected" which verifies that the underlying database
> connection is still valid, returning a boolean:
> >
> >     $connection connected
>
> Simple enough!
> >
> > I have implemented these changes for the postgres and mysql drivers,
> using a global Tcl_HashTable protected with a mutex to store the
> ConnectionData struct against the issued handle (with the pidata removed).
>
> Simple enough again.  Even an array with linear searching would be
> workable, since we're highly unlikely to be dealing with thousands (or
> even hundreds) of connections in a process.
>

Agreed, and a linear search through an array or linked list would be better
in this case I'm sure, I just did the easy thing :)

> If a driver lacks these additions, the behaviour falls back to detach ->
> destroy, and tdbc::pool will just always construct a fresh connection
> object, so it is backwards and forwards compatible with drivers that don't
> know about the connection pooling.
>
> Perfect!
>
> ODBC would be easy enough to add. There's already a global mutex in
> the driver because the SQLENV (needed for connection construction and
> a few other bits) is per-process. With SQLite3 being entirely
> in-process, and with the fact that we have all the overhead coming
> from the fact that its driver is written in Tcl atop an existing Tcl
> API, it's probably a game not worth the candle. The native Oracle
> driver is moribund, and the only other driver I'm aware of is Steve
> Redler's network-proxy thing.  You've done the hard part.
>

Yeah, I left SQLite3 alone because I doubt there is any win doing this
dance just to avoid the database open call, and is probably quite
challenging since the "underlying database connection" in this case is the
sqlite3 tcl command for the open database and its associated state.  It
might be interesting to investigate but my intuition suggests that without
an expensive connection setup there isn't much to gain.

ODBC looks like it would be almost identical to the mysql and postgres
drivers, just the Tcl_Obj* connectionString member of the ConnectionData
might need care when detaching from an interp.  I don't have an odbc
datasource to test against currently though, and I'm not that familiar with
it in general.


>
> > I have a basic set of test cases for the changes in the postgres and
> mysql drivers, and the connection pool machinery itself (currently
> implemented in the TDBC core package, in Tcl code).  If this feature is
> something that could be merged, then I'll write the docs and try to write
> test cases for the more pathological race conditions.
>
> > It currently supports vanilla Tcl using the Thread package, and
> NaviServer using it's own threading (because thread::create interacts badly
> NaviServer during certain parts of the server startup).  That means there
> is some polyfill code to provide thread::send when using NaviServer's
> threads, which lack that capability (using [chan pipe]).  Since my
> motivation for this connection pooling mechanism is to replace ns_db in
> NaviServer for rubylane.com, it's important to me that it works in
> NaviServer, but the polyfill may be too grubby and specific for TDBC
> generally.  It could be merged with just Thread support and I'll just
> maintain the polyfill for NaviServer separately for our use.
>
> Fraser's Law: All the world's problems are solved with one more layer
> of indirection.
>
> I'd be fine separating the communication interface from
> implementation, and if we choose not to ship the NaviServer plugin,
> the API will still be there to support it. (The Notifier in 8.4-8.6
> was a similar decision: it was implemented at C level with an abstract
> API [a structure of function pointers], and only one implementation
> shipped per platform. Browser plugins replaced the implementation as
> part of their initialization.
>
> That's kind of what OO is for, isn't it?
>
> --
> 73 de ke9tv/2, Kevin
>

Re: [Tcl-tdbc] Connection pooling for TDBC

[Kevin K. <kev...@gm...>]

On Tue, Feb 11, 2020 at 9:32 AM Cyan Ogilvie <cya...@gm...> wrote:
> I've put together a thread-aware connection pooling mechanism for TDBC and would like to know if there is interest in merging the changes into TDBC itself, and if so, what the process for that would be.

This sounds like a terrific idea. At this point, the process is quite
informal - we publish 'Informational' TIP's for major API changes, but
that's about it.

I'm presuming that the 'thread-aware'-ness is at the driver (and
connection attachment) level? At the higher levels, there are quite a
lot of Tcl_Obj's about, and the logic is mostly designed as
'multi-interp-safe and thread-oblivious'.

> The design looks like this:
>
> To retrieve a handle from the pool:
>
>     tdbc::${driver}::connection create db -host localhost -db foo
>
> becomes:
>
>     tdbc::pool $driver create db -host localhost -db foo
>
> When the thread is finished with the connection, it instead of
>
>     db destroy   (or db close)
>
> it would do:
>
>     db release
>
> which destroys db and any statements and resultsets associated with it, rolls back the transaction if one is open, and parks the database handle for the connection in a pool of detached connections.  The next call to tdbc::pool that matches the driver and connection arguments will retrieve the most recently released connection instead of creating a new connection (making it more of a stack than a pool).  This is done to keep the busy set of handles to a minimum and allow the idle ones to time out (2 minutes) and be closed.  This way the pool will grow as needed with a load spike and then shrink back down once the spike has passed and idle detached connections time out.

Nice, clean, simple.  I like it a lot.

I wonder if we could actually override the object destruction in some
way, or else go through a wrapper object, so that the user of the
connection would use 'db destroy' or 'rename db {}' in either case. I
can easily see myself forgetting which pathway to use when finalizing
a connection!

I'm copying Donal and Sean on this so as to get suggestions from the
TclOO guru and the architecture astronaut. I could certainly work up
wrapping logic that would work, but I'm guessing that they will point
out subtleties that I will miss.

> When tdbc::pool issues a connection from the pool (creating a fresh one if needed), and he pool is empty, it initiates a new connection in a background thread and adds it to the pool, priming it for the next request.  The intent of the pooling mechanism is primarily to hide the connection setup latency from short-lived users of the db handles, as is typical of web server usage patterns.
>
> Time to get a handle from the pool on my test machine is between 80 and 300 microseconds, vs 7000 to 18000 microseconds without the pool (postgres or mysql database on localhost).

Sweet!

Now I'm thinking. Having some sort of wrapper object would be really
nice, because another potential performance win would be to allow a
pooled connection to retain its prepared statements. That would be
trickier, since the Statement object isn't thread-safe at present, but
most of the stuff in it could be transferred among threads without too
much baggage. I _think_. No time right now to delve into it, I'm
afraid.

> The detached connections in the pool are periodically checked (every 20 seconds), and those that are no longer connected to the server or which are older than 2 minutes are closed and removed from the pool.  If the pool size goes to 0 as a result, a new connection is created to prime the pool.

Does this create a blip every 20 seconds on an idle application, where
a never-used connection is closed and immediately reopened? Is this
intentional, perhaps to make sure that the server connection is still
live, or am I misunderstanding what's up here?

> In order to support connection pooling, a TDBC driver needs 3 things:
>
> - Support construction with a single parameter "-attach $handle", which should create a new connection instance and attach it to the previously detached database handle indicated by $handle:
>
>     tdbc::${driver}::connection new -attach $handle
>
> - A new method "detach" that destroys the connection and returns a handle that can be used in the future to reattach to this database connection (possibly from another thread):
>
>     $connection detach
>
> - A new method "connected" which verifies that the underlying database connection is still valid, returning a boolean:
>
>     $connection connected

Simple enough!
>
> I have implemented these changes for the postgres and mysql drivers, using a global Tcl_HashTable protected with a mutex to store the ConnectionData struct against the issued handle (with the pidata removed).

Simple enough again.  Even an array with linear searching would be
workable, since we're highly unlikely to be dealing with thousands (or
even hundreds) of connections in a process.

> If a driver lacks these additions, the behaviour falls back to detach -> destroy, and tdbc::pool will just always construct a fresh connection object, so it is backwards and forwards compatible with drivers that don't know about the connection pooling.

Perfect!

ODBC would be easy enough to add. There's already a global mutex in
the driver because the SQLENV (needed for connection construction and
a few other bits) is per-process. With SQLite3 being entirely
in-process, and with the fact that we have all the overhead coming
from the fact that its driver is written in Tcl atop an existing Tcl
API, it's probably a game not worth the candle. The native Oracle
driver is moribund, and the only other driver I'm aware of is Steve
Redler's network-proxy thing.  You've done the hard part.

> I have a basic set of test cases for the changes in the postgres and mysql drivers, and the connection pool machinery itself (currently implemented in the TDBC core package, in Tcl code).  If this feature is something that could be merged, then I'll write the docs and try to write test cases for the more pathological race conditions.

> It currently supports vanilla Tcl using the Thread package, and NaviServer using it's own threading (because thread::create interacts badly NaviServer during certain parts of the server startup).  That means there is some polyfill code to provide thread::send when using NaviServer's threads, which lack that capability (using [chan pipe]).  Since my motivation for this connection pooling mechanism is to replace ns_db in NaviServer for rubylane.com, it's important to me that it works in NaviServer, but the polyfill may be too grubby and specific for TDBC generally.  It could be merged with just Thread support and I'll just maintain the polyfill for NaviServer separately for our use.

Fraser's Law: All the world's problems are solved with one more layer
of indirection.

I'd be fine separating the communication interface from
implementation, and if we choose not to ship the NaviServer plugin,
the API will still be there to support it. (The Notifier in 8.4-8.6
was a similar decision: it was implemented at C level with an abstract
API [a structure of function pointers], and only one implementation
shipped per platform. Browser plugins replaced the implementation as
part of their initialization.

That's kind of what OO is for, isn't it?

-- 
73 de ke9tv/2, Kevin

[Tcl-tdbc] Connection pooling for TDBC

[Cyan O. <cya...@gm...>]

I've put together a thread-aware connection pooling mechanism for TDBC and
would like to know if there is interest in merging the changes into TDBC
itself, and if so, what the process for that would be.

The design looks like this:

To retrieve a handle from the pool:

    tdbc::${driver}::connection create db -host localhost -db foo

becomes:

    tdbc::pool $driver create db -host localhost -db foo

When the thread is finished with the connection, it instead of

    db destroy   (or db close)

it would do:

    db release

which destroys db and any statements and resultsets associated with it,
rolls back the transaction if one is open, and parks the database handle
for the connection in a pool of detached connections.  The next call to
tdbc::pool that matches the driver and connection arguments will retrieve
the most recently released connection instead of creating a new connection
(making it more of a stack than a pool).  This is done to keep the busy set
of handles to a minimum and allow the idle ones to time out (2 minutes) and
be closed.  This way the pool will grow as needed with a load spike and
then shrink back down once the spike has passed and idle detached
connections time out.

When tdbc::pool issues a connection from the pool (creating a fresh one if
needed), and he pool is empty, it initiates a new connection in a
background thread and adds it to the pool, priming it for the next
request.  The intent of the pooling mechanism is primarily to hide the
connection setup latency from short-lived users of the db handles, as is
typical of web server usage patterns.

Time to get a handle from the pool on my test machine is between 80 and 300
microseconds, vs 7000 to 18000 microseconds without the pool (postgres or
mysql database on localhost).

The detached connections in the pool are periodically checked (every 20
seconds), and those that are no longer connected to the server or which are
older than 2 minutes are closed and removed from the pool.  If the pool
size goes to 0 as a result, a new connection is created to prime the pool.

In order to support connection pooling, a TDBC driver needs 3 things:

- Support construction with a single parameter "-attach $handle", which
should create a new connection instance and attach it to the previously
detached database handle indicated by $handle:

    tdbc::${driver}::connection new -attach $handle

- A new method "detach" that destroys the connection and returns a handle
that can be used in the future to reattach to this database connection
(possibly from another thread):

    $connection detach

- A new method "connected" which verifies that the underlying database
connection is still valid, returning a boolean:

    $connection connected

I have implemented these changes for the postgres and mysql drivers, using
a global Tcl_HashTable protected with a mutex to store the ConnectionData
struct against the issued handle (with the pidata removed).

If a driver lacks these additions, the behaviour falls back to detach ->
destroy, and tdbc::pool will just always construct a fresh connection
object, so it is backwards and forwards compatible with drivers that don't
know about the connection pooling.

I have a basic set of test cases for the changes in the postgres and mysql
drivers, and the connection pool machinery itself (currently implemented in
the TDBC core package, in Tcl code).  If this feature is something that
could be merged, then I'll write the docs and try to write test cases for
the more pathological race conditions.

It currently supports vanilla Tcl using the Thread package, and NaviServer
using it's own threading (because thread::create interacts badly NaviServer
during certain parts of the server startup).  That means there is some
polyfill code to provide thread::send when using NaviServer's threads,
which lack that capability (using [chan pipe]).  Since my motivation for
this connection pooling mechanism is to replace ns_db in NaviServer for
rubylane.com, it's important to me that it works in NaviServer, but the
polyfill may be too grubby and specific for TDBC generally.  It could be
merged with just Thread support and I'll just maintain the polyfill for
NaviServer separately for our use.

Cyan

Re: [Tcl-tdbc] Issue with tdbcodbc using ODBC Driver 17 for SQL Server

[Kevin K. <kev...@gm...>]

On Thu, Jan 23, 2020 at 10:21 AM Tom Gossler
<Tom...@si...> wrote:
>
> Ok, I can hear the laughter already!

It happens to the best of us.

> I figured out my own issue this morning after a fresh cup of coffee and good night sleep.  The format of my SQL statement was not valid.  After some small change to the code, it is working fine today.

Glad you fixed your own problem!  I was just getting ready to dive
into it with a fresh cup of coffee, after I didn't spot anything
obvious last night.  Now I don't have to!

Re: [Tcl-tdbc] Issue with tdbcodbc using ODBC Driver 17 for SQL Server

[Harald O. <har...@el...>]

Am 23.01.2020 um 16:10 schrieb Tom Gossler:
> Ok, I can hear the laughter already!
> 
> I figured out my own issue this morning after a fresh cup of coffee and
> good night sleep.  The format of my SQL statement was not valid.  After
> some small change to the code, it is working fine today.
> 
> Sorry for the knee-jerk reaction of the "issue" in tdbc!  You Tcl
> developers rock!

No problem. Writing such a good error description is often the best step
to find the issue...

Re: [Tcl-tdbc] Issue with tdbcodbc using ODBC Driver 17 for SQL Server

[Tom G. <Tom...@si...>]

Ok, I can hear the laughter already!

I figured out my own issue this morning after a fresh cup of coffee and 
good night sleep.  The format of my SQL statement was not valid.  After 
some small change to the code, it is working fine today.

Sorry for the knee-jerk reaction of the "issue" in tdbc!  You Tcl 
developers rock!

On 1/22/2020 3:29 PM, to...@si... wrote:
>
> Good morning,
>
> I have been working on scripting processes for customers of mine and 
> ran into what appears to be a problem in tdbc when performing INSERT 
> INTO <tblname>(<column>, <column>, ...) VALUES(<value>, <value>, ...);
>
> I was successful building the table using the tdbc::odbc and doing 
> INSERT rows as above if I _hard-code_ the values.
>
> Instead, if I use VALUES(':value1', ':value2', ...) using 
> single-quotes around character fields, none around numeric fields and 
> attempt to bind variables into the value fields, the process breaks 
> with the following SQL Server messages:
>
> [Microsoft][ODBC Driver 17 for SQL Server][SQL Server]String or binary 
> data would be truncated.
> [Microsoft][ODBC Driver 17 for SQL Server][SQL Server]The statement 
> has been terminated.
> (executing the statement)
>
> If I do not use the single-quotes around the character fields, it 
> fails instead with:
>
> [Microsoft][ODBC Driver 17 for SQL Server][SQL Server]String data, 
> right truncation.
> (executing the statement)
>
> Yes, I have verified that the data values being inserted are equal to 
> or less in length than the column definitions in the table.  In fact 
> to ensure there would not be any problems, all columns were 
> deliberately created larger than necessary.  And as I stated 
> previously, if I hard-code the values into a SQL statement an
> use tdbc::odbc to insert the data, it works fine.  Here is a example 
> of the hard-code module I ran:
>
> package require tdbc::odbc
> tdbc::odbc::connection create db_conn "DRIVER={ODBC Driver 17 for SQL 
> Server};DATABASE=<dbname>;SERVER=<svrnm>;Uid=<usrid>;Pwd=<usrpwd>;"
>
> set eDocsPut [db_conn prepare { INSERT INTO <tblnm>(col1, col2, col3, 
> col4, col5, col6, col7) VALUES('XXXX', 2362401134, 000000002, 
> '20130102040038_edocs_d130101_t064907_1', 2362401134000, 00000016750, 
> 00000032749);}]
>
> $eDocsPut execute
> $eDocsPut close
> db_connn close
>
> The above code successfully inserts the row into the table.  The 
> following code however, does not.
>
> package require tdbc::odbc
> tdbc::odbc::connection create db_conn "DRIVER={ODBC Driver 17 for SQL 
> Server};DATABASE=<dbname>;SERVER=<svrnm>;Uid=<usrid>;Pwd=<usrpwd>;"
>
> set eDocsPut [db_conn prepare { INSERT INTO <tblnm>(col1, col2, col3, 
> col4, col5, col6, col7) VALUES(':col1', :col2, :col3, ':col4', :col5, 
> :col6, :col7);}]
>
> set col1 "XXXX"
> set col2 2362401134
> set col3    000000002
> set col4    "20130102040038_edocs_d130101_t064907_1"
> set col5    2362401134000
> set col6    00000016750
> set col7    00000032749
>
> $eDocsPut execute
> $eDocsPut close
> db_connn close
>
> Returning the row inserted by the hard-coded process (which also works 
> successfully using tdbc::odbc!) we get:
>
> col1 {XXXX } col2 2362401134 col3 2 col4 
> {20130102040038_edocs_d130101_t064907_1            } col5 
> 2362401134000 col6 16750 col7 32749
>
> Any help you could provide is Greatly appreciated!
>
>
>
> _______________________________________________
> Tcl-tdbc mailing list
> Tcl...@li...
> https://lists.sourceforge.net/lists/listinfo/tcl-tdbc

[Tcl-tdbc] Issue with tdbcodbc using ODBC Driver 17 for SQL Server

[<to...@si...>]

Good morning,

I have been working on scripting processes for customers of mine and ran 
into what appears to be a problem in tdbc when performing INSERT INTO 
<tblname>(<column>, <column>, ...) VALUES(<value>, <value>, ...);

I was successful building the table using the tdbc::odbc and doing 
INSERT rows as above if I _hard-code_ the values.

Instead, if I use VALUES(':value1', ':value2', ...) using single-quotes 
around character fields, none around numeric fields and attempt to bind 
variables into the value fields, the process breaks with the following 
SQL Server messages:

[Microsoft][ODBC Driver 17 for SQL Server][SQL Server]String or binary 
data would be truncated.
[Microsoft][ODBC Driver 17 for SQL Server][SQL Server]The statement has 
been terminated.
(executing the statement)

If I do not use the single-quotes around the character fields, it fails 
instead with:

[Microsoft][ODBC Driver 17 for SQL Server][SQL Server]String data, right 
truncation.
(executing the statement)

Yes, I have verified that the data values being inserted are equal to or 
less in length than the column definitions in the table.  In fact to 
ensure there would not be any problems, all columns were deliberately 
created larger than necessary.  And as I stated previously, if I 
hard-code the values into a SQL statement an
use tdbc::odbc to insert the data, it works fine.  Here is a example of 
the hard-code module I ran:

package require tdbc::odbc
tdbc::odbc::connection create db_conn "DRIVER={ODBC Driver 17 for SQL 
Server};DATABASE=<dbname>;SERVER=<svrnm>;Uid=<usrid>;Pwd=<usrpwd>;"

set eDocsPut [db_conn prepare { INSERT INTO <tblnm>(col1, col2, col3, 
col4, col5, col6, col7) VALUES('XXXX', 2362401134, 000000002, 
'20130102040038_edocs_d130101_t064907_1', 2362401134000, 00000016750, 
00000032749);}]

$eDocsPut execute
$eDocsPut close
db_connn close

The above code successfully inserts the row into the table.  The 
following code however, does not.

package require tdbc::odbc
tdbc::odbc::connection create db_conn "DRIVER={ODBC Driver 17 for SQL 
Server};DATABASE=<dbname>;SERVER=<svrnm>;Uid=<usrid>;Pwd=<usrpwd>;"

set eDocsPut [db_conn prepare { INSERT INTO <tblnm>(col1, col2, col3, 
col4, col5, col6, col7) VALUES(':col1', :col2, :col3, ':col4', :col5, 
:col6, :col7);}]

set col1    "XXXX"
set col2 2362401134
set col3    000000002
set col4    "20130102040038_edocs_d130101_t064907_1"
set col5    2362401134000
set col6    00000016750
set col7    00000032749

$eDocsPut execute
$eDocsPut close
db_connn close

Returning the row inserted by the hard-coded process (which also works 
successfully using tdbc::odbc!) we get:

col1 {XXXX } col2 2362401134 col3 2 col4 
{20130102040038_edocs_d130101_t064907_1            } col5 2362401134000 
col6 16750 col7 32749

Any help you could provide is Greatly appreciated!

[Tcl-tdbc] Schedule Up - 26th Annual Tcl/Tk Conference (Tcl'2019)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

26th Annual Tcl/Tk Conference (Tcl'2019)
https://www.tcl-lang.org/community/tcl2019/

November 05 - 08, 2019
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ NEWS
  * Our keynote speaker is [Will Duquette](https://github.com/wduquette)
    talking about "Tcl, Rust, and the Death of Rube Goldberg"

  * Registration is open. Please have a look at

    https://www.tcl-lang.org/community/tcl2019/register.html

  * The tutorials are known. See

    https://www.tcl-lang.org/community/tcl2019/tutorials.html
]

And our schedule for this year is now available at

    https://www.tcl-lang.org/community/tcl2019/schedule.html

This is the last general mail for the year.

Conference Committee

   * Andreas Kupries
   * Arjen Markus    Deltares
   * Brian Griffin   Mentor - A Siemens Business
   * Gerald Lester   KnG Consulting LLC
   * Joe Mistachkin  Mistachkin Systems
   * Ronald Fox      CAEN Technologies
                     NSCL @ Michigan State University

Contact Information     tcl...@go...

Tcl'2019 would like to thank those who are sponsoring the conference:

   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp

[Tcl-tdbc] 4th Call For Papers - Extended Deadline - 26th Annual Tcl/Tk Conference (Tcl'2019)

[<con...@tc...>]

Today is the original deadline for paper submissions. We are __extending__
this deadline_by one week, to __Sep 16, 2019, i.e. next Monday__.

Hello tcl-tdbc, fyi ...

26th Annual Tcl/Tk Conference (Tcl'2019)
https://www.tcl-lang.org/community/tcl2019/

November 05 - 08, 2019
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ NEWS
  * Our keynote speaker is [Will Duquette](https://github.com/wduquette)
    talking about "Tcl, Rust, and the Death of Rube Goldberg"

  * [Submission is open](https://www.tcl-lang.org/community/tcl2019/cfp.html)

    We are at the original deadline for submissions. It has been extended
    by one week.

  * Registration is open. Please have a look at

    https://www.tcl-lang.org/community/tcl2019/register.html

  * The tutorials are known. See

    https://www.tcl-lang.org/community/tcl2019/tutorials.html
]

Important Dates:

Abstracts and proposals due   September 09, 2019  ** Extended by a week **
Notification to authors       September 16, 2019
WIP and BOF reservations open August 12, 2019
Registration opens            September 09, 2019     ** open already **
Author materials due          October 14, 2019
Tutorials Start               November 04, 2019
Conference starts             November 06, 2019

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2019 will be held in Houston, Texas, USA from November 05, 2019 to November 08, 2019.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: https://www.tcl-lang.org/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than September 09, 2019. Authors of accepted
abstracts will have until October 14, 2019 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	https://www.tcl-lang.org/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in August 12, 2019. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in August 12, 2019. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (https://www.tcl-lang.org/community/tcl2019/) and will be
published on various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: https://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Andreas Kupries
   * Arjen Markus    Deltares
   * Brian Griffin   Mentor - A Siemens Business
   * Gerald Lester   KnG Consulting LLC
   * Joe Mistachkin  Mistachkin Systems
   * Ronald Fox      CAEN Technologies
                     NSCL @ Michigan State University

Contact Information     tcl...@go...

Tcl'2019 would like to thank those who are sponsoring the conference:

   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp

[Tcl-tdbc] 3rd Call For Papers - 26th Annual Tcl/Tk Conference (Tcl'2019)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

26th Annual Tcl/Tk Conference (Tcl'2019)
https://www.tcl-lang.org/community/tcl2019/

November 04 - 08, 2019
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ NEWS
  * Our keynote speaker is [Will Duquette](https://github.com/wduquette)
    talking about "Tcl, Rust, and the Death of Rube Goldberg"

  * [Submission is open](https://www.tcl-lang.org/community/tcl2019/cfp.html)

    It is 4 weeks to the deadline.

  * Registration is open. Please have a look at

    https://www.tcl-lang.org/community/tcl2019/register.html

  * The tutorials are known. See

    https://www.tcl-lang.org/community/tcl2019/tutorials.html
]

Important Dates:

Abstracts and proposals due   September 09, 2019
Notification to authors       September 16, 2019
WIP and BOF reservations open August 12, 2019     ** may change **
Registration opens            September 09, 2019     ** open already **
Author materials due          October 14, 2019
Tutorials Start               November 04, 2019
Conference starts             November 06, 2019

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2019 will be held in Houston, Texas, USA from November 04, 2019 to November 08, 2019.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: https://www.tcl-lang.org/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than September 09, 2019. Authors of accepted
abstracts will have until October 14, 2019 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	https://www.tcl-lang.org/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in August 12, 2019. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in August 12, 2019. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (https://www.tcl-lang.org/community/tcl2019/) and will be
published on various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: https://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Andreas Kupries
   * Arjen Markus    Deltares
   * Brian Griffin   Mentor - A Siemens Business
   * Gerald Lester   KnG Consulting LLC
   * Joe Mistachkin  Mistachkin Systems
   * Ronald Fox      CAEN Technologies
                     NSCL @ Michigan State University

Contact Information     tcl...@go...

Tcl'2019 would like to thank those who are sponsoring the conference:

   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp

[Tcl-tdbc] 2nd Call For Papers - 26th Annual Tcl/Tk Conference (Tcl'2019)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

26th Annual Tcl/Tk Conference (Tcl'2019)
https://www.tcl-lang.org/community/tcl2019/

November 04 - 08, 2019
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ NEWS
 * Our keynote speaker is [Will Duquette](https://github.com/wduquette)
   talking about "Tcl, Rust, and the Death of Rube Goldberg"

 * [Submission is open](https://www.tcl-lang.org/community/tcl2019/cfp.html)
]

Important Dates:

Abstracts and proposals due   September 09, 2019
Notification to authors       September 16, 2019
WIP and BOF reservations open August 12, 2019     ** may change **
Registration opens            September 09, 2019     ** may change **
Author materials due          October 14, 2019
Tutorials Start               November 04, 2019
Conference starts             November 06, 2019

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2019 will be held in Houston, Texas, USA from November 04, 2019 to November 08, 2019.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: https://www.tcl-lang.org/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than September 09, 2019. Authors of accepted
abstracts will have until October 14, 2019 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	https://www.tcl-lang.org/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in August 12, 2019. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in August 12, 2019. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (https://www.tcl-lang.org/community/tcl2019/) and will be
published on various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: https://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Andreas Kupries
   * Arjen Markus    Deltares
   * Brian Griffin   Mentor - A Siemens Business
   * Gerald Lester   KnG Consulting LLC
   * Joe Mistachkin  Mistachkin Systems
   * Ronald Fox      CAEN Technologies
                     NSCL @ Michigan State University

Contact Information     tcl...@go...

Tcl'2019 would like to thank those who are sponsoring the conference:

   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp

[Tcl-tdbc] 1st Call For Papers - 26th Annual Tcl/Tk Conference (Tcl'2019)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

26th Annual Tcl/Tk Conference (Tcl'2019)
https://www.tcl-lang.org/community/tcl2019/

November 04 - 08, 2019
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ NEWS
 * [Submission is open](https://www.tcl-lang.org/community/tcl2019/cfp.html)
]

Important Dates:

Abstracts and proposals due   September 09, 2019
Notification to authors       September 16, 2019
WIP and BOF reservations open August 12, 2019     ** may change **
Registration opens            September 09, 2019     ** may change **
Author materials due          October 14, 2019
Tutorials Start               November 04, 2019
Conference starts             November 06, 2019

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2019 will be held in Houston, Texas, USA from November 04, 2019 to November 08, 2019.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: https://www.tcl-lang.org/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than September 09, 2019. Authors of accepted
abstracts will have until October 14, 2019 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	https://www.tcl-lang.org/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in August 12, 2019. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in August 12, 2019. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (https://www.tcl-lang.org/community/tcl2019/) and will be
published on various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: https://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Andreas Kupries
   * Arjen Markus    Deltares
   * Brian Griffin   Mentor - A Siemens Business
   * Gerald Lester   KnG Consulting LLC
   * Joe Mistachkin  Mistachkin Systems
   * Ronald Fox      CAEN Technologies
                     NSCL @ Michigan State University

Contact Information     tcl...@go...

Tcl'2019 would like to thank those who are sponsoring the conference:

   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp

[Tcl-tdbc] 4th Call For Papers - 25th Annual Tcl/Tk Conference (Tcl'2018)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

25th Annual Tcl/Tk Conference (Tcl'2018)
http://www.tcl.tk/community/tcl2018/

October 15 - 19, 2018
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

Important Dates:

[[ Attention!

   Counting down we are now bit a shy of 4 weeks to the submission
   deadline.

 * [Registration is open](https://www.tcl.tk/community/tcl2018/register.html)

 * [Submission is open](https://www.tcl.tk/community/tcl2018/cfp.html)

 * Our Keynote speaker is
   [Andrea Casotto](https://www.tcl.tk/community/tcl2018/bios.html#acasotto)

 * [The tutorials are known](http://www.tcl.tk/community/tcl2018/tutorials.html)
   Just follow the link.
]]

Important Dates:

Abstracts and proposals due   August 20, 2018
Notification to authors       August 27, 2018
WIP and BOF reservations open July 23, 2018     ** may change **
Registration opens            IS OPEN
Author materials due          September 24, 2018
Tutorials Start               October 15, 2018
Conference starts             October 17, 2018

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2018 will be held in Houston, Texas, USA from October 15, 2018 to October 19, 2018.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: http://www.tcl.tk/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than August 20, 2018. Authors of accepted
abstracts will have until September 24, 2018 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	http://www.tcl.tk/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in July 23, 2018. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in July 23, 2018. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (http://www.tcl.tk/community/tcl2018/) and will be published on
various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: http://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Alexandre Ferrieux
   * Andreas Kupries
   * Arjen Markus       Deltares
   * Brian Griffin      Mentor - A Siemens Business
   * Clif Flynt         Noumena Corp
   * Gerald Lester      RubyLane
   * Joe Mistachkin     Mistachkin Systems
   * Ronald Fox         CAEN Technologies
                        NSCL @ Michigan State University
   * Steve Landers      Digital Smarties

Contact Information     tcl...@go...

Tcl'2018 would like to thank those who are sponsoring the conference:

   * ActiveState Inc
   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp
   * Tcl Community Association

[Tcl-tdbc] 3rd Call For Papers - 25th Annual Tcl/Tk Conference (Tcl'2018)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

25th Annual Tcl/Tk Conference (Tcl'2018)
http://www.tcl.tk/community/tcl2018/

October 15 - 19, 2018
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ Reminder
 
 * [Registration is open](https://www.tcl.tk/community/tcl2018/register.html)

 * [Submission is open](https://www.tcl.tk/community/tcl2018/cfp.html)

 * Our Keynote speaker is
   [Andrea Casotto](https://www.tcl.tk/community/tcl2018/bios.html#acasotto)
]

Important Dates:

Abstracts and proposals due   August 20, 2018
Notification to authors       August 27, 2018
WIP and BOF reservations open July 23, 2018     ** may change **
Registration opens            IS OPEN
Author materials due          September 24, 2018
Tutorials Start               October 15, 2018
Conference starts             October 17, 2018

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2018 will be held in Houston, Texas, USA from October 15, 2018 to October 19, 2018.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: http://www.tcl.tk/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than August 20, 2018. Authors of accepted
abstracts will have until September 24, 2018 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	http://www.tcl.tk/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in July 23, 2018. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in July 23, 2018. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (http://www.tcl.tk/community/tcl2018/) and will be published on
various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: http://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Alexandre Ferrieux
   * Andreas Kupries
   * Arjen Markus       Deltares
   * Brian Griffin      Mentor - A Siemens Business
   * Clif Flynt         Noumena Corp
   * Gerald Lester      RubyLane
   * Joe Mistachkin     Mistachkin Systems
   * Ronald Fox         CAEN Technologies
                        NSCL @ Michigan State University
   * Steve Landers      Digital Smarties

Contact Information     tcl...@go...

Tcl'2018 would like to thank those who are sponsoring the conference:

   * ActiveState Inc
   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp
   * Tcl Community Association

[Tcl-tdbc] ANNOUNCE: tdbc::odbc support for 32-bit SQLWCHAR

[Kevin K. <kev...@gm...>]

Today, I merged onto the tdbc::odbc trunk Christian Werner's changes for
support of ODBC systems (specifically, iodbc) that use a 32-bit SQLWCHAR.
By dint of sufficiently clever programming, the tdbc::odbc driver is able
to detect at run time whether SQLWCHAR is 16 or 32 bits, and adapt its
operation accordingly, so binary distributors need not worry about matching
tdbc::odbc to the particular ODBC in use. Many other ODBC-using systems on
Unix need to have separate versions for unixodbc and iodbc, but Tcl escapes
that.

Because this is a significant added capability (enabling the support of
MacOSX and BSD-derived systems), I advanced the minor version from 1.0 to
1.1.

Many thanks to Christian for managing to develop the solution, and to Ashok
Nadkarni for being our tester for all things Windows!

[Tcl-tdbc] 2nd Call For Papers - 25th Annual Tcl/Tk Conference (Tcl'2018)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

25th Annual Tcl/Tk Conference (Tcl'2018)
http://www.tcl.tk/community/tcl2018/

October 15 - 19, 2018
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

[ NEWS
 
 * [Registration is open](https://www.tcl.tk/community/tcl2018/register.html)

 * [Submission is open](https://www.tcl.tk/community/tcl2018/cfp.html)

 * Our Keynote speaker is
   [Andrea Casotto](https://www.tcl.tk/community/tcl2018/bios.html#acasotto)
]

Important Dates:

Abstracts and proposals due   August 20, 2018
Notification to authors       August 27, 2018
WIP and BOF reservations open July 23, 2018     ** may change **
Registration opens            IS OPEN
Author materials due          September 24, 2018
Tutorials Start               October 15, 2018
Conference starts             October 17, 2018

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2018 will be held in Houston, Texas, USA from October 15, 2018 to October 19, 2018.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: http://www.tcl.tk/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than August 20, 2018. Authors of accepted
abstracts will have until September 24, 2018 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	http://www.tcl.tk/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in July 23, 2018. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in July 23, 2018. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (http://www.tcl.tk/community/tcl2018/) and will be published on
various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: http://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Alexandre Ferrieux
   * Andreas Kupries
   * Arjen Markus       Deltares
   * Brian Griffin      Mentor - A Siemens Business
   * Clif Flynt         Noumena Corp
   * Gerald Lester      RubyLane
   * Joe Mistachkin     Mistachkin Systems
   * Ronald Fox         CAEN Technologies
                        NSCL @ Michigan State University
   * Steve Landers      Digital Smarties

Contact Information     tcl...@go...

Tcl'2018 would like to thank those who are sponsoring the conference:

   * ActiveState Inc
   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp
   * Tcl Community Association

[Tcl-tdbc] 1st Call For Papers - 25th Annual Tcl/Tk Conference (Tcl'2018)

[<con...@tc...>]

Hello tcl-tdbc, fyi ...

25th Annual Tcl/Tk Conference (Tcl'2018)
http://www.tcl.tk/community/tcl2018/

October 15 - 19, 2018
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

Important Dates:

Abstracts and proposals due   August 20, 2018
Notification to authors       August 27, 2018
WIP and BOF reservations open July 23, 2018     ** may change **
Registration opens            August 20, 2018     ** may change **
Author materials due          September 24, 2018
Tutorials Start               October 15, 2018
Conference starts             October 17, 2018

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2018 will be held in Houston, Texas, USA from October 15, 2018 to October 19, 2018.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences (Proceedings: http://www.tcl.tk/community/conferences.html)
have seen submissions covering a wide variety of topics including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than August 20, 2018. Authors of accepted
abstracts will have until September 24, 2018 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com
Online proceedings will appear via
	http://www.tcl.tk/community/conferences.html

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in July 23, 2018. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in July 23, 2018. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (http://www.tcl.tk/community/tcl2018/) and will be published on
various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference, subscribe to the
tcl...@go... list. See:
https://groups.google.com/forum/#!forum/tclconference for list
information, archive, and subscription.

To keep in touch with Tcl events in general, subscribe to the
tcl-announce list. See: http://code.activestate.com/lists/tcl-announce
for list information, archive, and subscription.

Conference Committee

   * Alexandre Ferrieux
   * Andreas Kupries
   * Arjen Markus       Deltares
   * Brian Griffin      Mentor - A Siemens Business
   * Clif Flynt         Noumena Corp
   * Gerald Lester      RubyLane
   * Joe Mistachkin     Mistachkin Systems
   * Ronald Fox         CAEN Technologies
                        NSCL @ Michigan State University
   * Steve Landers      Digital Smarties

Contact Information     tcl...@go...

Tcl'2018 would like to thank those who are sponsoring the conference:

   * ActiveState Inc
   * FlightAware
   * Mentor - A Siemens Business
   * Noumena Corp
   * Tcl Community Association

[Tcl-tdbc] 3rd Call For Papers - 24th Annual Tcl/Tk Conference (Tcl'2017)

[<aku...@sh...>]

Hello tcl-tdbc, fyi ...

24th Annual Tcl/Tk Conference (Tcl'2017)
http://www.tcl.tk/community/tcl2017/

October 16 - 20, 2017
Crowne Plaza Houston River Oaks
2712 Southwest Freeway, 77098
Houston, Texas, USA

Important Dates:

[[ Attention!
   Counting down 2 weeks to the submission deadline.

   Registration is open. Please have a look at
     http://www.tcl.tk/community/tcl2017/register.html

   The tutorials are known. See
     http://www.tcl.tk/community/tcl2017/tutorials.html
]]

Abstracts and proposals due   August 21, 2017
Notification to authors       August 28, 2017
WIP and BOF reservations open July 24, 2017
Author materials due          September 25, 2017
Tutorials Start               October 16, 2017
Conference starts             October 18, 2017

Email Contact:                tcl...@go...

Submission of Summaries

Tcl/Tk 2017 will be held in Houston, Texas, USA from October 16, 2017 to October 20, 2017.

The program committee is asking for papers and presentation proposals
from anyone using or developing with Tcl/Tk (and extensions). Past
conferences have seen submissions covering a wide variety of topics
including:

* Scientific and engineering applications
* Industrial controls
* Distributed applications and Network Managment
* Object oriented extensions to Tcl/Tk
* New widgets for Tk
* Simulation and application steering with Tcl/Tk
* Tcl/Tk-centric operating environments
* Tcl/Tk on small and embedded devices
* Medical applications and visualization
* Use of different programming paradigms in Tcl/Tk and proposals for new
  directions.
* New areas of exploration for the Tcl/Tk language

Submissions should consist of an abstract of about 100 words and a
summary of not more than two pages, and should be sent as plain text
to tcl...@go... no later than August 21, 2017. Authors of accepted
abstracts will have until September 25, 2017 to submit their final
paper for the inclusion in the conference proceedings. The proceedings
will be made available on digital media, so extra materials such as
presentation slides, code examples, code for extensions etc. are
encouraged.

Printed proceedings will be produced as an on-demand book at lulu.com

The authors will have 30 minutes to present their paper at
the conference.

The program committee will review and evaluate papers according to the
following criteria:

* Quantity and quality of novel content
* Relevance and interest to the Tcl/Tk community
* Suitability of content for presentation at the conference

Proposals may report on commercial or non-commercial systems, but
those with only blatant marketing content will not be accepted.

Application and experience papers need to strike a balance between
background on the application domain and the relevance of Tcl/Tk to
the application. Application and experience papers should clearly
explain how the application or experience illustrates a novel use of
Tcl/Tk, and what lessons the Tcl/Tk community can derive from the
application or experience to apply to their own development efforts.

Papers accompanied by non-disclosure agreements will be returned to
the author(s) unread. All submissions are held in the highest
confidentiality prior to publication in the Proceedings, both as a
matter of policy and in accord with the U. S. Copyright Act of 1976.

The primary author for each accepted paper will receive registration
to the Technical Sessions portion of the conference at a reduced rate.

Other Forms of Participation

The program committee also welcomes proposals for panel discussions of
up to 90 minutes. Proposals should include a list of confirmed
panelists, a title and format, and a panel description with position
statements from each panelist. Panels should have no more than four
speakers, including the panel moderator, and should allow time for
substantial interaction with attendees. Panels are not presentations
of related research papers.

Slots for Works-in-Progress (WIP) presentations and Birds-of-a-Feather
sessions (BOFs) are available on a first-come, first-served basis
starting in July 24, 2017. Specific instructions for reserving WIP
and BOF time slots will be provided in the registration information
available in July 24, 2017. Some WIP and BOF time slots will be held open
for on-site reservation. All attendees with an interesting work in
progress should consider reserving a WIP slot.

Registration Information

More information on the conference is available the conference Web
site (http://www.tcl.tk/community/tcl2017/) and will be published on
various Tcl/Tk-related information channels.

To keep in touch with news regarding the conference and Tcl events in
general, subscribe to the tcl-announce list. See:
http://code.activestate.com/lists/tcl-announce to subscribe to the
tcl-announce mailing list.


Conference Committee

   * Alexandre Ferrieux
   * Andreas Kupries    SUSE
   * Arjen Markus       Deltares
   * Brian Griffin      Mentor Graphics - A Siemens Business
   * Clif Flynt         Noumena Corp
   * Gerald Lester      RubyLane
   * Joe Mistachkin     Mistachkin Systems
   * Ronald Fox         CAEN Technologies
                        NSCL @ Michigan State University
   * Steve Landers      Digital Smarties

Contact Information     tcl...@go...

Tcl'2017 would like to thank those who are sponsoring the conference:

   * FlightAware
   * Mentor Graphics - A Siemens Business
   * Noumena Corp
   * Tcl Community Association