The document discusses using LotusScript (LS) to connect Lotus Notes databases to external relational databases. It covers LSX, LS:DO, and DCR as methods for database connectivity from LotusScript server-side agents. The presentation provides code examples and discusses object-oriented design patterns for database connectivity classes. It demonstrates connecting to an Access database using ODBC and connecting to an Oracle database from LotusScript. The document emphasizes best practices like error handling, logging, and separating database-specific code.
The rise of NoSQL is characterized with confusion and ambiguity; very much like any fast-emerging organic movement in the absence of well-defined standards and adequate software solutions. Whether you are a developer or an architect, many questions come to mind when faced with the decision of where your data should be stored and how it should be managed. The following are some of these questions: What does the rise of all these NoSQL technologies mean to my enterprise? What is NoSQL to begin with? Does it mean "No SQL"? Could this be just another fad? Is it a good idea to bet the future of my enterprise on these new exotic technologies and simply abandon proven mature Relational DataBase Management Systems (RDBMS)? How scalable is scalable? Assuming that I am sold, how do I choose the one that fit my needs best? Is there a middle ground somewhere? What is this Polyglot Persistence I hear about? The answers to these questions and many more is the subject of this talk along with a survey of the most popular of NoSQL technologies. Be there or be square.
Hybernat and structs, spring classes in mumbai
best Hybernat and structs, spring classes in mumbai with job assistance.
our features are:
expert guidance by it industry professionals
lowest fees of 5000
practical exposure to handle projects
well equiped lab
after course resume writing guidance
Solving the C20K problem: Raising the bar in PHP Performance and ScalabilityZendCon
How do you configure and tune your PHP applications to handle 20,000
or more concurrent connections to your database on your desktop? This technical session describes how to implement and tune PHP's OCI8 extension with Oracle's Database Resident Connection Pool (DRCP).
The rise of NoSQL is characterized with confusion and ambiguity; very much like any fast-emerging organic movement in the absence of well-defined standards and adequate software solutions. Whether you are a developer or an architect, many questions come to mind when faced with the decision of where your data should be stored and how it should be managed. The following are some of these questions: What does the rise of all these NoSQL technologies mean to my enterprise? What is NoSQL to begin with? Does it mean "No SQL"? Could this be just another fad? Is it a good idea to bet the future of my enterprise on these new exotic technologies and simply abandon proven mature Relational DataBase Management Systems (RDBMS)? How scalable is scalable? Assuming that I am sold, how do I choose the one that fit my needs best? Is there a middle ground somewhere? What is this Polyglot Persistence I hear about? The answers to these questions and many more is the subject of this talk along with a survey of the most popular of NoSQL technologies. Be there or be square.
Hybernat and structs, spring classes in mumbai
best Hybernat and structs, spring classes in mumbai with job assistance.
our features are:
expert guidance by it industry professionals
lowest fees of 5000
practical exposure to handle projects
well equiped lab
after course resume writing guidance
Solving the C20K problem: Raising the bar in PHP Performance and ScalabilityZendCon
How do you configure and tune your PHP applications to handle 20,000
or more concurrent connections to your database on your desktop? This technical session describes how to implement and tune PHP's OCI8 extension with Oracle's Database Resident Connection Pool (DRCP).
RAPID - Building a highly usable API Design language with XTextTed Epstein
The challenge: Create a highly readable, user-friendly design language for REST APIs, suitable for use by cross-functional enterprise teams.
The toolkit: XText language framework for Eclipse IDE.
The result: RAPID -- the Resource API Design language, used in RepreZen API Studio.
In this presentation, RepreZen's Tanya Fesenko and Ted Epstein show why they decided to create a new API language in this already crowded space, and how they differentiated by raising the bar on usability. This presentation demonstrates to XText language developers some of the techniques required to build this kind of language.
RepreZen DSL: Pushing the limits of language usability with XTextTatiana Tanya Fesenko
Many DSLs are convenient alternatives to hand-coding or generic data formats. Others are unique in their solution space, providing the best way, sometimes the only way, to describe a particular model or program.
But what about DSLs that have to compete with other languages? When language readability, extensibility, and efficiency of expression are key to the success of your product, what language design ideas can we bring to the table, and what techniques will make them work in XText?
RepreZen is an Eclipse-based API design environment, with its own DSL to describe REST APIs and supporting data types. As a new entry in the competitive and rapidly evolving API design space, it wasn't enough to offer new capabilities; we needed to raise the already high bar of usability set by other API description languages. And we needed to streamline the DSL design process for fast evolution, adding new language constructs with each beta release.
In this talk, we'll explain our language design goals, and show how we implemented some especially challenging language features, including:
* Use of a generic meta-syntax to formalize grammatical patterns in the DSL, enabling greater consistency and more centralized logic for formatting, syntax highlighting, code assist, etc. Language extensibility and platform portability are also benefits of this DSL design pattern.
* Optional fluency, which accommodates concise or fluent coding styles, according to the user's preference, through the use of optional keywords.
* Indent-based block scoping in XText, similar to YAML or Python.
* Flexible sequencing of language constructs for improved usability, with an option to automate canonical ordering for consistency across models.
JavaScript Frameworks and Java EE – A Great MatchReza Rahman
The sea change in JavaScript frameworks is shifting the pendulum away from today's thin-client based server-side web frameworks like Spring MVC and JSF to JavaScript powered rich clients. With strong support for REST, WebSocket and JSON, Java EE is well positioned to adapt to this landscape.
In this heavily code driven session, we will show you how you can utilize today's most popular JavaScript frameworks like AngularJS and React to utilize the core strengths of Java EE using JAX-RS, WebSocket, JSON-P, JSON-B, CDI and Bean Validation.
How to measure and optimize performance of applications that use Zend Framework 1.x. A talk presented at the New York City Zend Framework Meetup (http://www.meetup.com/ZendFramework-NYCmetro/) on August 23, 2011.
Architectural Patterns and Software Architectures: Client-Server, Multi-Tier,...Svetlin Nakov
Few days ago I gave a talk about software architectures. My goal was to explain as easy as possible the main ideas behind the most popular software architectures like the client-server model, the 3-tier and multi-tier layered models, the idea behind SOA architecture and cloud computing, and few widely used architectural patterns like MVC (Model-View-Controller), MVP (Model-View-Presenter), PAC (Presentation Abstraction Control), MVVM (Model-View-ViewModel). In my talk I explain that MVC, MVP and MVVM are not necessary bound to any particular architectural model like client-server, 3-tier of SOA. MVC, MVP and MVVM are architectural principles applicable when we need to separate the presentation (UI), the data model and the presentation logic.
Additionally I made an overview of the popular architectural principals IoC (Inversion of Control) and DI (Dependency Injection) and give examples how to build your own Inversion of Control (IoC) container.
Presenting Data – An Alternative to the View ControlTeamstudio
In this webinar, Paul Della-Nebbia, an IBM Champion, will show how to implement a different alternative for displaying information from Domino views. Paul will cover how to use the Dojo Data Grid (included with XPages) to display a data grid that provides unique features like infinite scrolling, click to sort column headers, adjustable column widths, filtering, and the ability to drag and drop column headers to reorder. As the user scrolls through, the view data is retrieved as needed which improves performance and usability.
Hibernate 3: Hibernate-What it is ?, ORM and Issues, Hibernate Hello World CRUD, Hello world with Servlet, Hibernate Object life cycle, Hibernate Architecture, Object as Component mapping, Hibernate Inheritance, Hibernate Unidirectional Mapping, Hibernate Bidirectional mapping, HQL, Native SQL queries, Named Quarries
Browser tools that make web development easierAlan Seiden
A departure from my usual PHP talks, I discussed browser-based tools that help with client-side tasks such as performance diagnostics, page analysis, HTTP flow analysis, the ability to step through javascript, and much more. Developers can work smarter with downloadable browser tools.
Move Your XPages Applications to the Fast LaneTeamstudio
Are your XPages applications performing like a Florida senior citizen driving in the left lane at 55 mph? A key to speeding up your XPages applications is knowledge of the:
-JSF lifecycle
-partial refresh
-and partial execution.
In this webinar, TLCC's Howard Greenberg covers these concepts and then applies them to optimizing an XPages application. Learn how to dramatically increase your XPages performance and make your users happy.
Take a whirlwind tour of the many ways in which Java can make your life better as a developer. We'll use Java in IBM Notes, Eclipse, and the latest IDEs. And we'll show you examples of best of breed libraries that can analyze data, create PDFs, and perform image processing on the fly. Get connected to IBM Connections, access relational data, open sockets, and parse feeds. And along the way we'll throw in tips for testing, performance, and writing good code.
Presenting Presenting changes in embedded CloverETL for IBM Infosphere MDM Master Data Management and new licensing options for CloverETL Designer and Server for partners and end users.
Hibernate ORM: Tips, Tricks, and Performance TechniquesBrett Meyer
DevNexus 2014
Out-of-the-box, Hibernate ORM offers limited overhead and decent throughput. Early-stage applications enjoy the convenience of ORM/JPA with great performance. However, scaling your application into an enterprise-level system introduces more demanding needs.
This talk will describe numerous tips and techniques to both increase Hibernate ORM performance, as well as decrease overhead. These include some basic tricks, such as mapping and fetching strategies. Entity enhancement instrumentation, third-party second level caching, Hibernate Search, and more complex considerations will also be discussed. The talk will include live demonstrations techniques and their before-and-after results.
Transformations: Smart Application Migration to XPagesTeamstudio
Migrating legacy applications with XPages without using any third party tools can be hard. Your code that was built and maintained over the years should be reused and ported to a current XPages environment. Oliver Busse will show you how to benefit from the possibilities of using Java in XPages to reproduce the functionality you already have and extend it to the next level, including:
-User profiles: create, use, and maintain
-Application profiles: reinvented
-Getting user and environment information: made easy and smart
-Transformation of the full-text search to a "facetted search" all over your application(s)
Flexible OLTP data models in the future
=================================
There has been a flurry of highly scalable data stores and a dramatic spike in the interest level. The solutions with the most mindshare seem to be inspired by Dynamo's (Amazon) eventually consistency model or a data model that promotes nested, self-describing data structures like BigTable from Google. At the same time you see projects within these corporations evolving to architectures like MegaStore and Dremel (Google) where features from the column-oriented data model is blended together with the relational model.
The shift from just highly structured data to unstructured and semistructured content is evident. New applications are being developed or existing applications are being modified at break neck speed. Developers want the data model evolution to be extremely simple and want support for nested structures so they can map to representations like JSON with ease so there is little impedance between the application programming model and the database. Next generation enterprise applications will increasingly work with structured and semi-structured data from a multitude of data sources. A pure relational model is too rigid and a pure BigTable like model has too many shortcomings and cannot be integrated with existing relational databases systems.
In this talk, I walk through an alternative. We prefer the familiar "row oriented" over "column oriented" approach but still tilt the relational model - mostly the schema definition to support partitioning and colocation, redundancy level and support for dynamic and nested columns.
Each of these extensions will support different desired attributes - partitioning and colocation primitives cover horizontal scaling, availability primitives allow explicit support for replication model and the placement policies (local vs across data centers), dynamic columns will address flexibility for schema evolution (different rows have different columns and added with no DDL requirements) and nested columns that support organizing data in a hierarchy.
We draw inspiration for the data model from Pat helland's 'Life beyond distributed transactions' by adopting entity groups as a first class artifact designers start with, and define relationships between entities within the group (associations based on reference as well as containment). Rationalizing the design around entity groups will force the designer to think about data access patterns and how the data will be colocated in partitions. We then cover why ACID properties and sophiticated querying becomes significantly less challenging to accomplish. There are many ideas around partitioning policies, tradeoffs in supporting transactions and joins across entity groups that are worth discussion.
The idea is to present a model and generate discussion on how to achieve the best of both worlds. Flexible schemas without losing referential integrity, support for associations and the po
RAPID - Building a highly usable API Design language with XTextTed Epstein
The challenge: Create a highly readable, user-friendly design language for REST APIs, suitable for use by cross-functional enterprise teams.
The toolkit: XText language framework for Eclipse IDE.
The result: RAPID -- the Resource API Design language, used in RepreZen API Studio.
In this presentation, RepreZen's Tanya Fesenko and Ted Epstein show why they decided to create a new API language in this already crowded space, and how they differentiated by raising the bar on usability. This presentation demonstrates to XText language developers some of the techniques required to build this kind of language.
RepreZen DSL: Pushing the limits of language usability with XTextTatiana Tanya Fesenko
Many DSLs are convenient alternatives to hand-coding or generic data formats. Others are unique in their solution space, providing the best way, sometimes the only way, to describe a particular model or program.
But what about DSLs that have to compete with other languages? When language readability, extensibility, and efficiency of expression are key to the success of your product, what language design ideas can we bring to the table, and what techniques will make them work in XText?
RepreZen is an Eclipse-based API design environment, with its own DSL to describe REST APIs and supporting data types. As a new entry in the competitive and rapidly evolving API design space, it wasn't enough to offer new capabilities; we needed to raise the already high bar of usability set by other API description languages. And we needed to streamline the DSL design process for fast evolution, adding new language constructs with each beta release.
In this talk, we'll explain our language design goals, and show how we implemented some especially challenging language features, including:
* Use of a generic meta-syntax to formalize grammatical patterns in the DSL, enabling greater consistency and more centralized logic for formatting, syntax highlighting, code assist, etc. Language extensibility and platform portability are also benefits of this DSL design pattern.
* Optional fluency, which accommodates concise or fluent coding styles, according to the user's preference, through the use of optional keywords.
* Indent-based block scoping in XText, similar to YAML or Python.
* Flexible sequencing of language constructs for improved usability, with an option to automate canonical ordering for consistency across models.
JavaScript Frameworks and Java EE – A Great MatchReza Rahman
The sea change in JavaScript frameworks is shifting the pendulum away from today's thin-client based server-side web frameworks like Spring MVC and JSF to JavaScript powered rich clients. With strong support for REST, WebSocket and JSON, Java EE is well positioned to adapt to this landscape.
In this heavily code driven session, we will show you how you can utilize today's most popular JavaScript frameworks like AngularJS and React to utilize the core strengths of Java EE using JAX-RS, WebSocket, JSON-P, JSON-B, CDI and Bean Validation.
How to measure and optimize performance of applications that use Zend Framework 1.x. A talk presented at the New York City Zend Framework Meetup (http://www.meetup.com/ZendFramework-NYCmetro/) on August 23, 2011.
Architectural Patterns and Software Architectures: Client-Server, Multi-Tier,...Svetlin Nakov
Few days ago I gave a talk about software architectures. My goal was to explain as easy as possible the main ideas behind the most popular software architectures like the client-server model, the 3-tier and multi-tier layered models, the idea behind SOA architecture and cloud computing, and few widely used architectural patterns like MVC (Model-View-Controller), MVP (Model-View-Presenter), PAC (Presentation Abstraction Control), MVVM (Model-View-ViewModel). In my talk I explain that MVC, MVP and MVVM are not necessary bound to any particular architectural model like client-server, 3-tier of SOA. MVC, MVP and MVVM are architectural principles applicable when we need to separate the presentation (UI), the data model and the presentation logic.
Additionally I made an overview of the popular architectural principals IoC (Inversion of Control) and DI (Dependency Injection) and give examples how to build your own Inversion of Control (IoC) container.
Presenting Data – An Alternative to the View ControlTeamstudio
In this webinar, Paul Della-Nebbia, an IBM Champion, will show how to implement a different alternative for displaying information from Domino views. Paul will cover how to use the Dojo Data Grid (included with XPages) to display a data grid that provides unique features like infinite scrolling, click to sort column headers, adjustable column widths, filtering, and the ability to drag and drop column headers to reorder. As the user scrolls through, the view data is retrieved as needed which improves performance and usability.
Hibernate 3: Hibernate-What it is ?, ORM and Issues, Hibernate Hello World CRUD, Hello world with Servlet, Hibernate Object life cycle, Hibernate Architecture, Object as Component mapping, Hibernate Inheritance, Hibernate Unidirectional Mapping, Hibernate Bidirectional mapping, HQL, Native SQL queries, Named Quarries
Browser tools that make web development easierAlan Seiden
A departure from my usual PHP talks, I discussed browser-based tools that help with client-side tasks such as performance diagnostics, page analysis, HTTP flow analysis, the ability to step through javascript, and much more. Developers can work smarter with downloadable browser tools.
Move Your XPages Applications to the Fast LaneTeamstudio
Are your XPages applications performing like a Florida senior citizen driving in the left lane at 55 mph? A key to speeding up your XPages applications is knowledge of the:
-JSF lifecycle
-partial refresh
-and partial execution.
In this webinar, TLCC's Howard Greenberg covers these concepts and then applies them to optimizing an XPages application. Learn how to dramatically increase your XPages performance and make your users happy.
Take a whirlwind tour of the many ways in which Java can make your life better as a developer. We'll use Java in IBM Notes, Eclipse, and the latest IDEs. And we'll show you examples of best of breed libraries that can analyze data, create PDFs, and perform image processing on the fly. Get connected to IBM Connections, access relational data, open sockets, and parse feeds. And along the way we'll throw in tips for testing, performance, and writing good code.
Presenting Presenting changes in embedded CloverETL for IBM Infosphere MDM Master Data Management and new licensing options for CloverETL Designer and Server for partners and end users.
Hibernate ORM: Tips, Tricks, and Performance TechniquesBrett Meyer
DevNexus 2014
Out-of-the-box, Hibernate ORM offers limited overhead and decent throughput. Early-stage applications enjoy the convenience of ORM/JPA with great performance. However, scaling your application into an enterprise-level system introduces more demanding needs.
This talk will describe numerous tips and techniques to both increase Hibernate ORM performance, as well as decrease overhead. These include some basic tricks, such as mapping and fetching strategies. Entity enhancement instrumentation, third-party second level caching, Hibernate Search, and more complex considerations will also be discussed. The talk will include live demonstrations techniques and their before-and-after results.
Transformations: Smart Application Migration to XPagesTeamstudio
Migrating legacy applications with XPages without using any third party tools can be hard. Your code that was built and maintained over the years should be reused and ported to a current XPages environment. Oliver Busse will show you how to benefit from the possibilities of using Java in XPages to reproduce the functionality you already have and extend it to the next level, including:
-User profiles: create, use, and maintain
-Application profiles: reinvented
-Getting user and environment information: made easy and smart
-Transformation of the full-text search to a "facetted search" all over your application(s)
Flexible OLTP data models in the future
=================================
There has been a flurry of highly scalable data stores and a dramatic spike in the interest level. The solutions with the most mindshare seem to be inspired by Dynamo's (Amazon) eventually consistency model or a data model that promotes nested, self-describing data structures like BigTable from Google. At the same time you see projects within these corporations evolving to architectures like MegaStore and Dremel (Google) where features from the column-oriented data model is blended together with the relational model.
The shift from just highly structured data to unstructured and semistructured content is evident. New applications are being developed or existing applications are being modified at break neck speed. Developers want the data model evolution to be extremely simple and want support for nested structures so they can map to representations like JSON with ease so there is little impedance between the application programming model and the database. Next generation enterprise applications will increasingly work with structured and semi-structured data from a multitude of data sources. A pure relational model is too rigid and a pure BigTable like model has too many shortcomings and cannot be integrated with existing relational databases systems.
In this talk, I walk through an alternative. We prefer the familiar "row oriented" over "column oriented" approach but still tilt the relational model - mostly the schema definition to support partitioning and colocation, redundancy level and support for dynamic and nested columns.
Each of these extensions will support different desired attributes - partitioning and colocation primitives cover horizontal scaling, availability primitives allow explicit support for replication model and the placement policies (local vs across data centers), dynamic columns will address flexibility for schema evolution (different rows have different columns and added with no DDL requirements) and nested columns that support organizing data in a hierarchy.
We draw inspiration for the data model from Pat helland's 'Life beyond distributed transactions' by adopting entity groups as a first class artifact designers start with, and define relationships between entities within the group (associations based on reference as well as containment). Rationalizing the design around entity groups will force the designer to think about data access patterns and how the data will be colocated in partitions. We then cover why ACID properties and sophiticated querying becomes significantly less challenging to accomplish. There are many ideas around partitioning policies, tradeoffs in supporting transactions and joins across entity groups that are worth discussion.
The idea is to present a model and generate discussion on how to achieve the best of both worlds. Flexible schemas without losing referential integrity, support for associations and the po
Wysoka Dostępność Windows Server 2008 w kontekscie umów SLATobias Koprowski
To trzecia prezentacja w cztero-częściowym cyklu omawiającym znaczenie wysokiej dostepności w kontekście umów SLA. Prezentacje przeznaczone są dla odbiorców z kręgu ITPro, a publikowane na zywo na portalu VirtualStudy.pl
***
This is third part of my four-parts cycle about Service Level Agreement for ITPros. It a session for Virtualstudy.pl education portal.
Framing the Argument: How to Scale Faster with NoSQLInside Analysis
The Briefing Room with Dr. Robin Bloor and IBM Cloudant
Live Webcast March 24, 2015
Watch the Archive: https://bloorgroup.webex.com/bloorgroup/onstage/g.php?MTID=e8bf62408d47e76c43aa73be08377e41c
Context matters. Perspective matters. Thinking outside the box? That's often the key! While the Structured Query Language remains the lingua Franca of data, there are some views of the world that are best rendered with the benefit of NoSQL engines. As usual, that's easier said than done. How can your organization migrate from a structured query to unstructured or semi-structured query language?
Register for this episode of The Briefing Room to find out! Veteran Analyst Dr. Robin Bloor will provide a detailed assessment of serious considerations when using NoSQL engines in conjunction with SQL. He'll be briefed by Ryan Millay of IBM Cloudant, who will showcase his company's solution, and how it's addressing the more vexing challenges facing today's information managers.
Visit InsideAnalysis.com for more information.
Introduction to Microservices with Docker and KubernetesDavid Charles
Slides used to accompany a talk to introduce Microservices and two related technologies; Docker and Kubernetes. A large part of this talk is a live demonstration of Docker and Kubernetes features so the slides are just to support.
Recent advances in DB2 and SQL can make PHP applications more secure, efficient, and require less code. Learn how to take advantage of a true enterprise-grade database: DB2 for IBM i. This tutorial will show the right way to use DB2 with PHP. Topics include: RCAC row and column security built into DB2, techniques to reduce the amount of required boilerplate PHP database code, new features of DB2 and ibm_db2 that can make life easier for developers, detailed performance tips, prevention of SQL injection, library list options, connecting to IBM i's DB2 from Windows and Linux, implementing pagination, using Zend\Db, and more. With new material presented for the first time anywhere.
Security regarding NoSQL Databases Still remain a question.Not much research done these databases,this paper concentrates on some of the major NoSQL databases and their flaws
Software Architecture and Architectors: useless VS valuableComsysto Reply GmbH
Abstract:
This talk introduces definitions of system architecture and proposes a way to achieve "good enough" architecture covers project requirements
Andrei will show several cases from real projects, where wrong, missing or over-sophisticated architecture decisions really hurt the development teams:
Painful sharing: do shared modules increase reusability or will be the source of problems?
Non-extensible extensibility: too sophisticated configuration hurts
Over fine-grained: incorrect splitting to microservices can make life even harder as with monolith
Cargo cult: blindly following patterns and rules can produce an unmaintainable system
Freestyle architecture: what happens if teams completely ignore architecture
Improve with less intelligence: smart endpoint and dumb pipes
We are looking forward to meet many of you in person and have great discussions around this topic!
https://www.meetup.com/de-DE/meetup-group-tfyvuydp/
Developing Connections Plug-ins and applications is full of "What the??" moments, from what browser technologies and versions are supported through to common functions working in different ways in different parts of Connections, any of these can put a real dent in your delivery date but most are easy to cure and avoid with a little bit of hindsight and knowledge, here is that knowledge for you to take home and help you deliver on time.
Cuando busca alternativas a Oracle en la nube, hacer el cambio puede parecer un trabajo duro. Entendemos que la migración involucra más que solo la base de datos. La compatibilidad es un punto clave, especialmente cuando se consideran los recursos que posiblemente ya haya invertido en Oracle, como por ejemplo el código de aplicación específico de Oracle.Este seminario web explorará las opciones y las principales consideraciones al pasar de las bases de datos de Oracle a la nube.
- Revisión detallada de las ofertas de bases de datos disponibles en la nube
- Factores críticos que se deben considerar considerar para elegir la oferta en la nube más adecuada
- Cómo la experiencia de EDB con PostgreSQL puede ayudarlo en su decisión
- Demostración de BigAnimal de EDB
Présentateur:
Sergio Romera, Senior Sales Engineer EMEA, EDB
------------------------------------------------------------
For more #webinars, visit http://bit.ly/EDB-Webinars
Download free #PostgreSQL whitepapers: http://bit.ly/EDB-Whitepapers
Read our #Postgres Blog http://bit.ly/EDB-Blogs
Follow us on Facebook at http://bit.ly/EDB-FB
Follow us on Twitter at http://bit.ly/EDB-Twitter
Follow us on LinkedIn at http://bit.ly/EDB-LinkedIn
Reach us via email at marketing@enterprisedb.com
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
Abstract
The idea of this talk is to help development teams to make correct architectural decisions.
Andrei will highlight the basic architectural principles and show ways to achieve architecture that is good enough to cover the project requirements and evolve in the future.
He will also present several cases from real projects, where wrong, missing, or over-sophisticated architecture decisions really hurt the development teams:
- Painful sharing: do shared modules increase reusability or will be the source of problems?
- Microservices are the solution to every problem!
- Non-extensible extensibility: too sophisticated configuration hurts
- Over fine-grained: incorrect splitting to Microservices can make life even harder as with monolith
- Convey horizontal split: how organizational driven split can jeopardise the architecture
- Model-driven: central responsibility blocks and limits the team
- Cargo cult: blindly following patterns and rule can produce an unmaintainable system
- Freestyle architecture: what happens if teams completely ignore architecture
- Improve with less intelligence: smart endpoint and dumb pipes
The presentation "Development for Administrators" was presented at AdminCamp 2006 in Germany, and a revised version presented at SoftSphere in Frankfurt in October 2007. This presentation intends to show Administrators:
Introduce proper development, UAT and production environments
show some basic @Formula language agents
Show some basic LotusScript functions
2. Why Are We Here?
• What is the target audience?
Lotus Notes developers who use server-based agents
• What is this talk about?
Lotus Notes is often perceived as a data “silo” …
Difficult to get data into
And difficult to get data out of
… this is not the case
This presentation explores a multitude of ways of interfacing
Notes databases with enterprise relational databases
2
3. Who Am I?
• Bill Buchan
• Dual Principal Certified Lotus Professional (PCLP) in v3,
v4, v5, v6, v7
• 10+ years senior development for Enterprise customers
Learn from my pain!
• 5+ years code auditing
• CEO of HADSL
Developing best-practice tools
3
5. Overview
• This session:
Is mostly about code
Lots of take-home code examples
Is a deep-dive in terms of theory
5
6. Connections: Overview
• “Lotus Notes cannot share its data with other
databases”
Absolutely not
Support for this dates back over 10 years!
• Multiple methods
This presentation leads you through some of the more
popular ones
Highlights the pros and cons of each
6
7. Connections: Overview (cont.)
LSX LS:DO DCR JNDI/XML
Performance High Low Med High
ODBC Connection Required No Yes Yes No
Native Client Required Yes No No Yes
Platform Independent Yes Yes Yes Yes
LotusScript Only Yes Yes Yes No
Supported Yes No Yes Yes
Runs on Client Yes Yes Yes Yes
Runs on Server Yes Yes No Yes
7
8. Tips: General
• In all of these examples, I shall hard-code user names
and passwords for simplicity
This is NOT a good production best practice!
Use encryption keys, profile documents, etc., to soft-code
these in production
• Any attempt by LotusScript to access data outside the
current database may result in error
Error handling is therefore mandatory
Logging of scheduled agents is mandatory
8
10. Overview: LSX
• LotusScript-based
Such a small learning curve
• Relies on native client support
So you have to install your database client and/or drivers
• Is fast
This doesn’t have to use ODBC
But ODBC is used for MS SQL and Access
Remember, ODBC v2 doesn’t like Unicode
This technology is used in the Lotus Enterprise Integrator
Formerly “Notespump”
Good for bulk transfer-style applications
10
11. Methodology
• We shall attempt to:
Test this against a local Access database using ODBC
Test this against an Oracle database
• Our data looks like:
• And for Access, we need an ODBC connection
11
12. Demo: Read Table to Log
• Let’s get a feel for what we are doing
• In this demonstration, we will:
Connect, using ODBC, to an Access database
Collect all records in a CUSTOMERS table
Pull ALL fields from all records
Write all this information to a Notes log
12
14. Architecture Design Goals
• When we write LSX applications, we should:
Write as little code as possible
Create comprehensive error handling
Create logs of both success and failure
Try not to hard-code the database structure
Try and reuse and componentize
After all, we might change databases later!
Ensure that our top-level logic is:
Focused on the business rules for data transfer
Is maintainable
After all, this will change!
14
15. Architecture Design Overview
• In order to access data, we must:
Connect to the database provider
And then connect to the data itself
• Object-oriented LotusScript lends itself to this model
We shall create a:
baseClass: This handles logging
baseConnectionClass: This handles the connection to the
data source
baseConnection<DB>Class: These are database-specific
classes
Operation classes
These should NOT be database specific
15
16. Architecture Design Results
• This means that we separate:
Logging
Basic connection
Operation
• Thus, reusing lots of code
• All database-specific code is held in a single library
Can be easily “swapped” for another
Platform and database differences can exist during our
operations
Test on the platform, version, and database that you will
implement on
16
17. Class Inheritance and Code Use
Logic for Connection BaseClass Logging, Error Handling
Code
BaseConnectionClass
ReadTableClass
BaseConnectionODBCClass
Operations Class
BaseConnectionOracleClass ODBC-Specific Code
Oracle-Specific Code Example agent uses a
specific database
connection and one or
more helper function
classes
Agent
17
18. Connecting to Oracle
• Now, let’s try connecting to Oracle
We need to:
Install the Oracle client
Connect it to the Oracle database server
18
19. Some Oracle Tips
• Setting up an Oracle server is not trivial
Oracle is an enterprise-strength database system
As big, complex, and difficult as a dozen mother-in-laws
So give yourself time!
• Some tips:
The Connection string in Oracle looks like:
CUSTOMERS_oracle02.marykirk.local
This is:
The name of the application — in our case “Customers”
And then the network host address
Either as a Domain Name System (DNS) host address
or as an Internet Protocol (IP) address
19
20. More Oracle Tips
• Try to use some Oracle tools to validate that you have:
A proper connection
Sufficient access to the application
Sufficient access to the tables
• Remember, you can use DCR to validate connections
20
21. Network Architecture
• If you run Lotus Connector (LC) LSX code on the server:
The server must have:
A connection to Oracle
The Oracle Client software drivers
• If you run LC LSX code on the Notes client:
The client must have:
A connection to Oracle
The Oracle Client software
• Installing Oracle Client on all workstations is not trivial!
Consider using LC LSX on the servers only
21
22. The Base Class
• Our base class Class baseClass
contains all ‘ returns true if this class is valid
“Infrastructure” Public Property Get Valid As Boolean
support, such as: ‘ Our constructor. Sets up logging
Logging Sub new()
Error trapping ‘ Class destructor ensures proper closure of Log
Sub delete()
‘ Log a message
Public Function logEvent(msg As String) As Integer
‘ Handle run-time errors
Private Function raiseError() As String
End Class
22
23. Class baseConnectorClass
' This class extends our BaseClass and adds the capability to open and close a connection
' Note that this is never used directly – and is overridden by our database-specific classes.
‘ This provides the business logic framework for our database specific connection classes
Class baseConnectorClass As BaseClass
‘ Expose some properties
Private Function getServer As String
Private Function getUserName As String
Private Function getPassword As String
Private Function getTable As String
Public Function getSession As LCSession
Public Function getConnection As LCConnection
' The base constructor for this class. Note that it doesnt actually
' do any connection work - it just sets up the base variables
Sub new(srv As String, un As String, pw As String, tb As String), baseClass()
‘ And the destructor. This ensures that the connection object is closed
Sub delete()
End Class
23
24. Class baseODBCConnectorClass
• All of our business logic is held in baseConnectorClass
We need to put the database-specific code in only this class
In this case, it is all implemented in the constructor
• If we change the business logic later on:
We have to change only baseConnectorClass
' This class extends our BaseConnectorClass and adds the
‘ capabilty to open and close an ODBC Connection
Class baseODBCConnectorClass As BaseConnectorClass
‘ Supply a new constructor for this class
Sub new(srv As String, un As String, pw As String, tb As String)
End sub
24
25. Insulating Database Connections from Business Logic
• One main goal is to insulate our database-specific
connection information from our business logic
It makes it easier to switch databases in the future, if
necessary
• In this database, I hold all database-specific information
in a profile document
Set docProfile = dbThis.GetProfileDocument("Profile")
Dim Connection As Variant
Select Case docProfile.Database(0)
Case "ODBC"
Set connection = New baseODBCConnectorClass _
(docProfile.System(0), "", "", "")
Case "Oracle"
Set connection = New baseOracleConnectorClass _
(docProfile.System(0), docProfile.UserName(0), docProfile.Password(0), docProfile.MetaData(0))
End Select
25
26. Class fieldClass
• fieldClass Class FieldClass
Helps us define which ‘ Our two members – a name and a field
fields we want returned Public FieldName As String
from our data object Public Field As LCField
Used to extract data ‘ get the value of this field
Property Get Value As Variant
‘ Construct this field class
Sub new(fName As String, F As LCField)
End Class
26
27. Class baseODBCConnectorClass — Constructor
• This pseudo-code Set Me.lc_Session = New LCSession()
shows the steps If ( Me.lc_Session.Status <> LCSUCCESS ) Then
towards connecting ‘ Bale out of the function…
to our LC LSX ‘ Check to see that the odbc2 LSX Support is available.
If (lc_Session.LookupConnector ("odbc2")) Then
target data server …
• Differences from an ‘ Now set up our Connection
ODBC connection Set me.lc_Connection = New LCConnection ( "odbc2" )
The connection token ‘ Set up our data source name
Me.lc_Connection.Server = Me.getServer()
is “oracle8”
The username and ‘ And finally connect
Me.lc_Connection.Connect
password are
specified ‘ Check to see that the connection has worked
If (Me.lc_Connection.isConnected = False) Then
…
27
28. ReadTableClass
• ReadTableClass Class ReadTableClass As baseClass
Allows us to read the result ‘ Our constructor. Pass in our
of an SQL Query ‘ database connection object
Sub new(newConn As Variant)
Returns each table row as a
LIST of FieldClass items ' set up our read operation
‘ by passing in an SQL statemement
Public Function getRecords( _
strSelection As String) As Long
‘ Call this till it returns false, return
‘ each row of the table as a list
‘ of resulting fields
Public Function getNextRecord( _
index As Long, returnedFields _
List As FieldClass) As Integer
End Class
28
29. Using ReadTableClass
• Our controlling code ‘ set up our database connection
Set connection = New _
Set up a database baseODBCConnectorClass( _
connection “CUSTOMERS”, "", "", "")
Create a ReadTableClass ‘ set up our ReadTableClass object
Dim rc As New ReadTableClass(connection)
object
‘ Check to see its valid
Check to see whether If Not rc.Valid Then
it’s valid …
‘ Do our SQL thing
Run some SQL If (rc.getRecords( _
"SELECT * from CUSTOMERS")) Then
Process the results While rc.getNextRecord(index, returnedValues)
…
29
30. Processing the Results from ReadTableClass
• It’s a case of: ------------------ New Record retrieved ----------
ID 1
Retrieving each ROW of data Name Lotus
Contact Mike R.hodin
Iterating through the LIST of Address Lotus House
fieldClass items and City
State
Westford
MA
processing them ZIP 90210
Country USA
• Agent “Read Tables to Log” dateFirstContact 01/01/1990 00:00:00
CreditLimit 5000000.0000
just prints them Employees 1000
…
Forall thisF In returnedValues
Call rc.logEvent(" " + thisF.fieldName + Space(30-Len(thisF.fieldName)) + _
Chr(9) +" [" + Cstr(thisF.Field.DataType) + "]" + Chr(9) + _
Implode(thisF.Field.Text, ", "))
End Forall
30
31. Demo: Read Table to Documents
• Let’s use the same underlying code:
Synchronize this information with Notes data
Use the ID field to match up SQL entries with Notes entries
For simplicity, we shall just overwrite the Notes data with
the SQL data
Note we are not requesting specific fields
We write ALL field information to a Notes database
We use the same field name in SQL and Notes
This might not be good in production
Consider pre-fixing the Notes field names to avoid
name collisions
31
33. Let’s Write to SQL
• In this case, we need to define which fields we shall
update
This information is used to define:
The SQL target field
Which field in Notes we pull data from
The data type
This had better match the SQL data type!
Again, we want the operations class to do all the hard work!
33
34. insertTablesClass
• Our class allows us to: Class InsertTableClass As baseClass
Define a series of field ' Our constructor. Pass in the Connector.
names we shall write Sub new(newConn As Variant)
data to ' Call this for each field we wish to append,
Pass a variant array of ‘ passing in a name and a type
Public Function appendField( _
values (in the same order fieldName As String, fieldType As Long) _
as our fields were As Integer
appended) ' Commit to inserting these records.
• This is still pretty hard ' This returns the number of records successfully
‘ inserted, NOT true or false.
work Public Function insertRecord( _
values() As Variant) As Integer
We have to track all
fields, etc. End Class
34
35. insertFieldClass
• insertFieldClass Class insertFieldClass
‘ Our constructor. Pass in our InsertTableClass
Helps define the Sub new(newIT As Variant)
fields, field types, ‘ Append a field name and an LSX field type
and values to Public Function appendField( _
transfer from the strName As String, Ltype As Long) As Integer
Notes document to ‘ Call this once you have set all your field names
the SQL table Public Function setUpFields() As Integer
For simplicity, in this ' Using our fieldList, save the field values
code instance we are ‘ from this document to to our InsertTableClass
Public Function saveFieldsFromDocument( _
assuming that the doc As NotesDocument) As Integer
field names are
identical in Notes End Class
and SQL
35
36. insertTableClass and insertFieldClass Usage
• Define a new ‘ Create a new InsertTable Class
InsertTableClass Dim it As New InsertTableClass(Connection)
‘ And create a InsertFieldClass, associating
• Define a new ‘ it with our table Class.
InsertFieldClass Dim ic As New InsertFieldClass(IT)
‘ Define the fields
Call ic.appendField("ID", LCTYPE_NUMERIC)
• Define our fields Call ic.appendField("Name", LCTYPE_TEXT)
…
‘ And “freeze” it there.
Call ic. setUpFields()
• Freeze the definition
‘ And for one or more Documents, push the
‘ Data across.
• Push the data Call ic.saveFieldsFromDocument(doc)
36
38. Performance
• Creating LCField items is expensive
We define our LCFields before inserting data
Instead of creating new LCField items within the loop for
each iteration, we create them ONCE outside the loop and
reuse them
Adds slightly to the complexity
Hence the requirement for insertFieldsClass
38
40. Introducing LotusScript Data Object (LS:DO)
• LS:DO was the first data interface
And is reportedly no longer supported
You may find some code that still relies on this
• LS:DO uses ODBC v2 drivers to access data
You cannot access Unicode data
This was introduced in ODBC v3.5
The client must have an ODBC definition for the target data
source on his machine, if you are running client-based code
• Let’s dive straight into a demo …
40
42. Using LS:DO
• Create a new connection Const SQL_TABLE = "CUSTOMERS"
Const SQL_QUERY =
"SELECT * FROM CUSTOMERS"
• Create a query and link it to our Set Connection = New ODBCConnection
connection Connection.ConnectTo(SQL_TABLE)
If Not Connection.IsConnected Then
• Create a result set and connect it …
to our query Dim Query As New ODBCQuery
Set Query.Connection = Connection
• Set the SQL query Dim Result As New ODBCResultSet
Set Result.Query = Query
• Execute the query Query.SQL = SQL_QUERY
Result.Execute
42
43. LS:DO Result Set Processing
• The ODBCResultSet Object now contains all the results
You can extract field information
You can extract actual values
This code extracts field name and size information
If Not Result.IsResultSetAvailable Then
Messagebox "I failed to get results from SQL Query: “ + _
SQL_QUERY, 48, "Failed to get Results"
Exit Sub
End If
Dim fields List As String
Dim i As Integer
For i = 1 To Result.NumColumns
Print "Field: " + padString( result.FieldName(i), 30) + _
"Size: " + padString(Cstr(Result.FieldSize(i)), 5)
fields(result.FieldName(i)) = result.FieldName(i)
Next
43
44. LS:DO Result Set Processing (cont.)
• To extract the result rows themselves, use:
Result.getNextRow ID
Name
1
Lotus
Result.IsEndOfData Contact
Address
Mike R.hodin
Lotus House
City Westford
State MA
ZIP 90210
Country USA
dateFirstContact 01/01/1990
CreditLimit 5000000
Employees 1000
While Not result.IsEndOfData
Forall thisField In fields
Print " " & padString( "" + thisField, 30 ) & Chr(9) & Result.GetValue(thisField)
End Forall
Call Result.NextRow()
Wend
44
45. LS:DO Tips
• LS:DO supports transaction processing
You could — if your SQL data source allowed — switch on
Transaction mode
odbcConnection.IsSupported(DB_SUPP_TRANSACTIONS)
You could then perform multiple updates
Commit them all at once
odbcConnection.CommitTransactions
45
46. LS:DO Summary
• LS:DO was a fairly simple, robust ODBC connection
You might have some code that relies on it
• I would advise you to:
Identify any code that relies on LS:DO
Refactor that code to use LSX
46
48. Introducing DCR
• Data Connection Resources (DCR)
New in Domino 6
Allows you to perform real-time, user-based SQL database
access
Very useful for front-end applications
• However:
It requires constant access to the target database
It requires Domino Enterprise Connection Services (DECS)
Running on the server on which your application is hosted
It pools all SQL database access via the DECS server
48
49. Create a New Shared Resource — Data Connection
• Set a name and alias
• Set the data connection type
• Enter username and password, if required
• Choose the data source
• And choose the object
• Use Browse metadata
to validate the connection
49
50. Link the Data Source to Your Form
• On the Form Properties — advanced tab, click Browse
Choose the data connection and the metadata object
50
51. Link the Fields to the Data
• On the field properties:
Check “External data source”
At the bottom, use the Browse
button to select the data source,
metadata
• One field needs to be defined as
the key field
• Remember to check “Store data
locally” if you want to see this
data on views!
51
52. DCR: What Would I Use It For?
• Very useful for:
Applications that are permanently connected
Applications that require instant lookup of external data
• You could use Notes information and …
Perform lookups to populate the document
Update status information on user request
52
53. Form Manipulation
• Bear in mind that all this logic is held on the Form
design element
You could use one Form to populate/refresh data
And allow users to work another Form
Which just displays the data on the document
53
54. Demo: DCR
• In this demo, I will:
Demonstrate data being updated in Notes and pushed to SQL
Demonstrate data being updated in SQL and pushed to Notes
Show you the DCR common element, as well as the Field
definition
54
57. Resources
• Constantin Florea, Notes and Domino Connectivity: A
Collection of Examples (IBM Redpaper, March 2001).
www.redbooks.ibm.com/redpapers/pdfs/redp0115.pdf
Check out the abstract here:
www.redbooks.ibm.com/abstracts/redp0115.html?Open
• Brian Benz and Rocky Oliver, Lotus Notes and Domino 6
Programming Bible (Wiley, 2003).
www.amazon.com/gp/product/0764526111
57
59. 7 Key Points to Take Home
• Domino can easily interact with other data sources
• LS:DO, whilst powerful and easy to use – is no longer
supported
Consider refactoring this
• LSX performs bulk updates between Domino and other
data sources
Simple, fast, efficient
• DCR allows real-time update in user context
And centralizes data lookup via the server
59
60. 7 Key Points to Take Home (cont.)
• Consider that the target data source will change
• Logging and error trapping
Mandatory
Ensure that you know of issues before your users
Monitor this interface
• This interface code will change often
Write for maintainability!
60
61. Your Turn!
How to contact me:
Bill Buchan
Bill@hadsl.com
61