In this lecture we look at the patterns in chapter 18 in the textbook (Patterns of Enterprise Application Architecture). The lecture is in two parts. First we go through each of the patterns and explain each.
Then in the second part we look at a problem we have to solve and try to get the patterns to show themselves at the time they are needed.
The Data Source Layer patterns introduced in lecture L08 are structural patterns. They deal with moving data to and from the database. They try to solve the impedance mismatch problem. However, they do not have any logic as to when and under what circumstances data should be loaded to from the database and when written. Clearly accessing the database is slow, and doing so needlessly hurts performance.
In this lecture we look at the behavioural problem. How to solve issues like writing only changed record back into the database, loading only the needed data once, and how to load the data model partially.
We introduce three new design patterns: Unit of Work, Identity Map and Lazy Load.
Vist the course home page: http://www.olafurandri.com/?page_id=2573
This document provides an overview of different data source patterns in software design including Table Data Gateway, Row Data Gateway, Active Record, Data Mapper, and Record Set. It discusses how these patterns work, when each one should be used, and examples of implementing them. It also covers some key objectives in connecting applications to data sources like relational databases and hiding SQL from the domain layer.
Oracle Sql Developer Data Modeler 3 3 new featuresPhilip Stoyanov
This document discusses new features in Oracle SQL Developer Data Modeler version 3.3/4.0, including enhanced search functionality, improved handling of logical and relational models including surrogate keys and subtyping, and support for identity columns in Oracle Database. Key new features include global and model-level searching, setting common properties on search results, custom reports on search results, improved mapping of relationships and attributes to relational models, and configuration options for implementing entity hierarchies and generating dependent constraints.
This lecture covered C# fundamentals including memory management, static vs non-static, properties, inheritance, and modifiers. It also discussed namespaces, assemblies, generics, collections, enumeration, abstract classes, interfaces, and polymorphism. The key topics were memory allocation on the stack vs heap, value types vs reference types, boxing and unboxing, inheritance and polymorphism, abstract classes vs interfaces, generics and collections, and enumerators. The assignment is to finish a database design and stored procedures based on a UML diagram.
This document discusses business logic layers and object-oriented design patterns. It begins by explaining what a business logic layer is and provides examples of services, entities, and rules/calculations. It then covers different patterns for structuring business logic, including procedure pattern, table module pattern, and object-based patterns like active record and domain model. Key differences between the patterns are explained. The remainder of the document dives deeper into object-oriented design patterns, categorizing them as creational, structural, and behavioral patterns. Examples are provided for factory, singleton, decorator, proxy, adapter, facade, strategy, and chain of responsibility patterns. Polymorphism and its importance to design patterns is also discussed.
The document discusses Hibernate, an object-relational mapping tool that transforms data between object representation and relational databases. It describes Hibernate's architecture, important definitions like SessionFactory and Session, configuration options including programmatic and XML configuration, mapping declarations, and persistent classes.
The document discusses Spring, a popular Java application framework. It provides definitions and explanations of key Spring concepts like frameworks, dependency injection, and the Spring application context. It describes the modular architecture of Spring, including core modules for aspects like data access, web, and AOP. It also compares Spring to Hibernate, explaining that Spring is a framework that helps follow MVC architecture while Hibernate provides object-relational mapping.
Hibernate is an object-relational mapping tool that allows developers to more easily write applications that interact with relational databases. It does this by allowing developers to map Java classes to database tables and columns, so that developers can interact with data through Java objects rather than directly with SQL statements. Hibernate handles the conversion between Java objects and database rows behind the scenes. Some key benefits of using Hibernate include faster data retrieval, avoiding manual database connection management, and easier handling of database schema changes.
The Data Source Layer patterns introduced in lecture L08 are structural patterns. They deal with moving data to and from the database. They try to solve the impedance mismatch problem. However, they do not have any logic as to when and under what circumstances data should be loaded to from the database and when written. Clearly accessing the database is slow, and doing so needlessly hurts performance.
In this lecture we look at the behavioural problem. How to solve issues like writing only changed record back into the database, loading only the needed data once, and how to load the data model partially.
We introduce three new design patterns: Unit of Work, Identity Map and Lazy Load.
Vist the course home page: http://www.olafurandri.com/?page_id=2573
This document provides an overview of different data source patterns in software design including Table Data Gateway, Row Data Gateway, Active Record, Data Mapper, and Record Set. It discusses how these patterns work, when each one should be used, and examples of implementing them. It also covers some key objectives in connecting applications to data sources like relational databases and hiding SQL from the domain layer.
Oracle Sql Developer Data Modeler 3 3 new featuresPhilip Stoyanov
This document discusses new features in Oracle SQL Developer Data Modeler version 3.3/4.0, including enhanced search functionality, improved handling of logical and relational models including surrogate keys and subtyping, and support for identity columns in Oracle Database. Key new features include global and model-level searching, setting common properties on search results, custom reports on search results, improved mapping of relationships and attributes to relational models, and configuration options for implementing entity hierarchies and generating dependent constraints.
This lecture covered C# fundamentals including memory management, static vs non-static, properties, inheritance, and modifiers. It also discussed namespaces, assemblies, generics, collections, enumeration, abstract classes, interfaces, and polymorphism. The key topics were memory allocation on the stack vs heap, value types vs reference types, boxing and unboxing, inheritance and polymorphism, abstract classes vs interfaces, generics and collections, and enumerators. The assignment is to finish a database design and stored procedures based on a UML diagram.
This document discusses business logic layers and object-oriented design patterns. It begins by explaining what a business logic layer is and provides examples of services, entities, and rules/calculations. It then covers different patterns for structuring business logic, including procedure pattern, table module pattern, and object-based patterns like active record and domain model. Key differences between the patterns are explained. The remainder of the document dives deeper into object-oriented design patterns, categorizing them as creational, structural, and behavioral patterns. Examples are provided for factory, singleton, decorator, proxy, adapter, facade, strategy, and chain of responsibility patterns. Polymorphism and its importance to design patterns is also discussed.
The document discusses Hibernate, an object-relational mapping tool that transforms data between object representation and relational databases. It describes Hibernate's architecture, important definitions like SessionFactory and Session, configuration options including programmatic and XML configuration, mapping declarations, and persistent classes.
The document discusses Spring, a popular Java application framework. It provides definitions and explanations of key Spring concepts like frameworks, dependency injection, and the Spring application context. It describes the modular architecture of Spring, including core modules for aspects like data access, web, and AOP. It also compares Spring to Hibernate, explaining that Spring is a framework that helps follow MVC architecture while Hibernate provides object-relational mapping.
Hibernate is an object-relational mapping tool that allows developers to more easily write applications that interact with relational databases. It does this by allowing developers to map Java classes to database tables and columns, so that developers can interact with data through Java objects rather than directly with SQL statements. Hibernate handles the conversion between Java objects and database rows behind the scenes. Some key benefits of using Hibernate include faster data retrieval, avoiding manual database connection management, and easier handling of database schema changes.
ApacheCon North America 2018: Creating Spark Data SourcesJayesh Thakrar
This document discusses building custom Spark data sources and provides an overview of the Spark data source API version 2. Building a custom data source allows exploiting special features of data sources that are not supported by existing built-in or third party data sources. The document outlines reasons for building a custom data source, the key interfaces that must be implemented as part of the data source API, and a code walkthrough of a simple example data source. It also discusses practical considerations like understanding the characteristics of the target data source. The data source API is still evolving so custom data sources may need to be updated for future Spark versions.
The document provides information about configuring Hibernate, an object-relational mapping tool for Java. It explains how to set up the Hibernate environment by downloading and installing Hibernate and its prerequisites. It also describes the important properties needed in the hibernate.cfg.xml configuration file to connect Hibernate to a MySQL database, including database connection URL, username, password and dialect. An example configuration file for MySQL is given.
Hibernate is an object-relational mapping tool that allows developers to interact with a relational database (such as MySQL) using object-oriented programming. It provides functionality for persisting Java objects to tables in a database and querying those objects using HQL or SQL. Hibernate utilizes XML mapping files or annotations to define how Java classes map to database tables. A typical Hibernate application includes entity classes, mapping files, configuration files, and a controller class to manage persistence operations.
MuleSoft Nashik Virtual Meetup#3 - Deep Dive Into DataWeave and its ModuleJitendra Bafna
Deep Dive Into DataWeave and its Modules
The document discusses DataWeave, MuleSoft's data transformation language. It covers DataWeave modules, operators, working with arrays and objects, and Mule runtime features. Key topics include DataWeave fundamentals like data types, reading/writing data, variables, operators, and flow control. Functions, filtering, mapping, reducing, and updating arrays and objects are also summarized.
Flush() synchronizes the database with pending changes in the persistence context. Close() ends the session and detaches all objects. Clear() detaches all objects but keeps the session open, allowing further work before needing to
Project Lambda: Functional Programming Constructs in Java - Simon Ritter (Ora...jaxLondonConference
Presented at JAX London 2013
The big language features for Java SE 8 are lambda expressions (closures) and default methods (formerly called defender methods or virtual extension methods). Adding lambda expressions to the language opens up a host of new expressive opportunities for applications and libraries. You might assume that lambda expressions are simply a more syntactically compact form of inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7.
This document discusses the data access layer (DAL) in .NET applications. The DAL is responsible for persisting the application's object model to the database in a configurable and database-independent way. It handles object-relational mapping and transaction management. The core .NET library used for database access is ADO.NET, which includes classes for connections, commands, data readers, and data adapters. Unit testing the DAL validates its behavior using assertions.
The Adventure: BlackRay as a Storage Enginefschupp
- BlackRay is an in-memory relational database and search engine that supports SQL and fulltext search. It was originally developed in 2005 for a phone directory with over 80 million records.
- The presentation discusses BlackRay's architecture, data loading process, indexing performance, and support for transactions, clustering, and APIs. It also describes efforts to implement BlackRay as a MySQL storage engine.
- Going forward, the team aims to improve SQL support, add security features, and explore using BlackRay as a backend for other applications like LDAP directories.
The document discusses the Data Access Object (DAO) pattern in J2EE applications. The DAO pattern separates business logic from data access logic. A DAO provides a common interface to access a data source. The DAO encapsulates data source access and manages data transfer objects (DTOs) that are used to exchange data between business objects and the DAO. Sample code illustrates a DAO interface, implementation, DTO, and client using the DAO to access inventory data without coupling to the specific data source implementation.
This document provides an overview of Hibernate, an object-relational mapping tool for Java. It begins with a list of topics covered and then defines what Hibernate and JDBC are. It describes the Hibernate architecture including configuration, sessions, and mapping. It also discusses annotations, HQL, caching and batch processing. The document provides details on configuring Hibernate with different databases as well as mapping files and object-relational mappings. It explains the use of annotations, HQL, criteria queries, and native SQL with Hibernate.
DataWeave is a new language for querying and transforming data that contains a data access layer enabling large payloads and random access without costly conversions. An example transforms a JSON file to XML using the DataWeave component in MuleSoft, which has input, DataWeave code, and output sections. The DataWeave code defines the mappings and output format, and changing the output type transforms the data to CSV or Java objects.
Presentazione del 24 ottobre 2013 presso JRC su:
- GeoUML tools (Catalogue e Validator)
- prototipo INSPIRE Data Model Browser
Nel webinar del 21 Novembre sono state illustrate solo alcune delle slide di questa presentazione.
Data access patterns and technologies are discussed. The Data Access Object (DAO) pattern separates data access from business logic. Spring JDBC and myBatis provide APIs for SQL queries and object mapping. Object-relational mapping (ORM) tools like Hibernate reduce code by mapping objects to relational databases but can reduce performance. JDBC template provides basic data access while frameworks offer additional features.
SQLPASS presentation on performance tuning and best practices for XML and XQuery in Microsoft SQL Server 2005, SQL Server 2008, SQL Server 2008 R2 and SQL Server 2012.
Igor Anishchenko
Odessa Java TechTalks
Lohika - September, 2012
This session starts with a high-level look at all that the Spring Data project has to offer.
Then we’ll dive deeper into a few select Spring Data modules, including Spring Data JPA, Spring Data MongoDB and Spring Data Redis.
Implementing a data access layer of an application has been cumbersome for quite a while. Too much boilerplate code had to be written!
Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose.
In addition to supporting the new “NoSQL” databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA -simplifies the development of creating a JPA-based data access layer.
A hibernate tutorial for beginners. It describe the hibernate concepts in a lucid manner and and test project(User application with database) to get hands on over the same.
This document summarizes new features in SQL Server 2008 for .NET developers, including spatial data support, BLOB storage using Filestream, enhancements to T-SQL, new date/time types, improved integration with Visual Studio, and business intelligence tools like Analysis Services, Integration Services, and Reporting Services.
This document summarizes new features in SQL Server 2008 for .NET developers, including spatial data support, BLOB storage using Filestream, enhancements to T-SQL, new date/time types, improved integration with Visual Studio, and business intelligence tools like Analysis Services, Integration Services, and Reporting Services.
This document discusses SQL and NoSQL approaches to scaling databases. It describes how social networks and other large-scale websites use techniques like sharding and messaging to partition data across many databases. It also discusses how SQL Server is adopting NoSQL paradigms like flexible schemas and federated sharding to provide scalability. The document aims to educate about scaling databases and how SQL Server is evolving to support both SQL and NoSQL approaches.
Processes are programs that run in data centers and have the role of executing specific tasks. They can be scheduled, triggered by an event or run manually. These programs handle task such as importing and exporting, reconciliation, daily updates and calculations and thing like that. Processes usually have no user interface except they log their progress to a log file.
In this lecture we create a process framework based on some of the design patterns we have covered. The idea is that this framework can be used to build processes, and as an example we create process call Import Content Process that reads RSS entries form a new site.
We also look briefly at XML.
At any given moment it is easy to look back to see how technology has changed over time. At the same time it is difficult to see what transformations are taking place in current moment, and even more difficult to see where things are going.
In the late 19th century a revolution in science took off. It was easy to see the vast number of inventions and entrepreneurial spirit of the time. At the dawn of the 20th century, it seems that everything had been invented. Yet, in the 20th century we saw more innovations and more technologically advanced than in all history of mankind before that. Never in history have we seen such dramatic changes in the way people live and work.
In this lecture we explore what to make of technology. We define the term we will use in the course. Terms defined are technology, product performance, and innovation to name few.
ApacheCon North America 2018: Creating Spark Data SourcesJayesh Thakrar
This document discusses building custom Spark data sources and provides an overview of the Spark data source API version 2. Building a custom data source allows exploiting special features of data sources that are not supported by existing built-in or third party data sources. The document outlines reasons for building a custom data source, the key interfaces that must be implemented as part of the data source API, and a code walkthrough of a simple example data source. It also discusses practical considerations like understanding the characteristics of the target data source. The data source API is still evolving so custom data sources may need to be updated for future Spark versions.
The document provides information about configuring Hibernate, an object-relational mapping tool for Java. It explains how to set up the Hibernate environment by downloading and installing Hibernate and its prerequisites. It also describes the important properties needed in the hibernate.cfg.xml configuration file to connect Hibernate to a MySQL database, including database connection URL, username, password and dialect. An example configuration file for MySQL is given.
Hibernate is an object-relational mapping tool that allows developers to interact with a relational database (such as MySQL) using object-oriented programming. It provides functionality for persisting Java objects to tables in a database and querying those objects using HQL or SQL. Hibernate utilizes XML mapping files or annotations to define how Java classes map to database tables. A typical Hibernate application includes entity classes, mapping files, configuration files, and a controller class to manage persistence operations.
MuleSoft Nashik Virtual Meetup#3 - Deep Dive Into DataWeave and its ModuleJitendra Bafna
Deep Dive Into DataWeave and its Modules
The document discusses DataWeave, MuleSoft's data transformation language. It covers DataWeave modules, operators, working with arrays and objects, and Mule runtime features. Key topics include DataWeave fundamentals like data types, reading/writing data, variables, operators, and flow control. Functions, filtering, mapping, reducing, and updating arrays and objects are also summarized.
Flush() synchronizes the database with pending changes in the persistence context. Close() ends the session and detaches all objects. Clear() detaches all objects but keeps the session open, allowing further work before needing to
Project Lambda: Functional Programming Constructs in Java - Simon Ritter (Ora...jaxLondonConference
Presented at JAX London 2013
The big language features for Java SE 8 are lambda expressions (closures) and default methods (formerly called defender methods or virtual extension methods). Adding lambda expressions to the language opens up a host of new expressive opportunities for applications and libraries. You might assume that lambda expressions are simply a more syntactically compact form of inner classes, but, in fact, the implementation of lambda expressions is substantially different and builds on the invokedynamic feature added in Java SE 7.
This document discusses the data access layer (DAL) in .NET applications. The DAL is responsible for persisting the application's object model to the database in a configurable and database-independent way. It handles object-relational mapping and transaction management. The core .NET library used for database access is ADO.NET, which includes classes for connections, commands, data readers, and data adapters. Unit testing the DAL validates its behavior using assertions.
The Adventure: BlackRay as a Storage Enginefschupp
- BlackRay is an in-memory relational database and search engine that supports SQL and fulltext search. It was originally developed in 2005 for a phone directory with over 80 million records.
- The presentation discusses BlackRay's architecture, data loading process, indexing performance, and support for transactions, clustering, and APIs. It also describes efforts to implement BlackRay as a MySQL storage engine.
- Going forward, the team aims to improve SQL support, add security features, and explore using BlackRay as a backend for other applications like LDAP directories.
The document discusses the Data Access Object (DAO) pattern in J2EE applications. The DAO pattern separates business logic from data access logic. A DAO provides a common interface to access a data source. The DAO encapsulates data source access and manages data transfer objects (DTOs) that are used to exchange data between business objects and the DAO. Sample code illustrates a DAO interface, implementation, DTO, and client using the DAO to access inventory data without coupling to the specific data source implementation.
This document provides an overview of Hibernate, an object-relational mapping tool for Java. It begins with a list of topics covered and then defines what Hibernate and JDBC are. It describes the Hibernate architecture including configuration, sessions, and mapping. It also discusses annotations, HQL, caching and batch processing. The document provides details on configuring Hibernate with different databases as well as mapping files and object-relational mappings. It explains the use of annotations, HQL, criteria queries, and native SQL with Hibernate.
DataWeave is a new language for querying and transforming data that contains a data access layer enabling large payloads and random access without costly conversions. An example transforms a JSON file to XML using the DataWeave component in MuleSoft, which has input, DataWeave code, and output sections. The DataWeave code defines the mappings and output format, and changing the output type transforms the data to CSV or Java objects.
Presentazione del 24 ottobre 2013 presso JRC su:
- GeoUML tools (Catalogue e Validator)
- prototipo INSPIRE Data Model Browser
Nel webinar del 21 Novembre sono state illustrate solo alcune delle slide di questa presentazione.
Data access patterns and technologies are discussed. The Data Access Object (DAO) pattern separates data access from business logic. Spring JDBC and myBatis provide APIs for SQL queries and object mapping. Object-relational mapping (ORM) tools like Hibernate reduce code by mapping objects to relational databases but can reduce performance. JDBC template provides basic data access while frameworks offer additional features.
SQLPASS presentation on performance tuning and best practices for XML and XQuery in Microsoft SQL Server 2005, SQL Server 2008, SQL Server 2008 R2 and SQL Server 2012.
Igor Anishchenko
Odessa Java TechTalks
Lohika - September, 2012
This session starts with a high-level look at all that the Spring Data project has to offer.
Then we’ll dive deeper into a few select Spring Data modules, including Spring Data JPA, Spring Data MongoDB and Spring Data Redis.
Implementing a data access layer of an application has been cumbersome for quite a while. Too much boilerplate code had to be written!
Spring Data is a project that makes it easier to build Spring-powered applications that use new data, offering a reasonably consistent programming model regardless of which type of database you choose.
In addition to supporting the new “NoSQL” databases such as document and graph databases, Spring Data also greatly simplifies working with RDBMS-oriented datastores using JPA -simplifies the development of creating a JPA-based data access layer.
A hibernate tutorial for beginners. It describe the hibernate concepts in a lucid manner and and test project(User application with database) to get hands on over the same.
This document summarizes new features in SQL Server 2008 for .NET developers, including spatial data support, BLOB storage using Filestream, enhancements to T-SQL, new date/time types, improved integration with Visual Studio, and business intelligence tools like Analysis Services, Integration Services, and Reporting Services.
This document summarizes new features in SQL Server 2008 for .NET developers, including spatial data support, BLOB storage using Filestream, enhancements to T-SQL, new date/time types, improved integration with Visual Studio, and business intelligence tools like Analysis Services, Integration Services, and Reporting Services.
This document discusses SQL and NoSQL approaches to scaling databases. It describes how social networks and other large-scale websites use techniques like sharding and messaging to partition data across many databases. It also discusses how SQL Server is adopting NoSQL paradigms like flexible schemas and federated sharding to provide scalability. The document aims to educate about scaling databases and how SQL Server is evolving to support both SQL and NoSQL approaches.
Processes are programs that run in data centers and have the role of executing specific tasks. They can be scheduled, triggered by an event or run manually. These programs handle task such as importing and exporting, reconciliation, daily updates and calculations and thing like that. Processes usually have no user interface except they log their progress to a log file.
In this lecture we create a process framework based on some of the design patterns we have covered. The idea is that this framework can be used to build processes, and as an example we create process call Import Content Process that reads RSS entries form a new site.
We also look briefly at XML.
At any given moment it is easy to look back to see how technology has changed over time. At the same time it is difficult to see what transformations are taking place in current moment, and even more difficult to see where things are going.
In the late 19th century a revolution in science took off. It was easy to see the vast number of inventions and entrepreneurial spirit of the time. At the dawn of the 20th century, it seems that everything had been invented. Yet, in the 20th century we saw more innovations and more technologically advanced than in all history of mankind before that. Never in history have we seen such dramatic changes in the way people live and work.
In this lecture we explore what to make of technology. We define the term we will use in the course. Terms defined are technology, product performance, and innovation to name few.
The document discusses several theories of innovation, including that new technologies are created by combining existing technologies in new ways (combinatory process), that innovation happens through exchange of ideas in liquid networks like coffee houses, and that the prepared and collaborative environment of these networks allows for serendipitous discoveries and "slow hunches" to develop into major innovations over time. Major innovations often have origins many years before becoming widely adopted due to the time it takes to build new platforms and for them to diffuse through populations according to theories like the adjacent possible and the 10/10 rule.
In the early days of product development, the technology is inferior and lacking in performance. The focus is very much on the technology itself. The users are enthusiast who like the idea of the product, find use for it, and except the lack of performance. Then as the product becomes more mature, other factors become important, such as price, design, features, portability. The product moves from being a technology to become a consumer item, and even a community.
In this lecture we explore the change from technology focus to consumer focus, and look at why people stand in line overnight to buy the latest gadgets.
Frameworks are general code libraries that developers use to build their software on. Frameworks are usually specific to a domain, like web frameworks or database frameworks. The benefit of frameworks is the productivity that they provide. With the right framework we can avoid writing low-level functionality and instead focus on our domain problems we need to solve. Frameworks are building blocks and should be used as such, if you have a bad framework or need to invest too much into using the framework, the gains are counter productive.
It may be a good strategy to write your own framework, and in the lecture we look at design patterns that are useful in creating frameworks. We will also look at the Spring framework that is a good example of a well design framework.
Cover image by Javier Corbo
http://www.flickr.com/photos/javiercorbo/
For the most time of human history, life was local and linear. Local in the way that anything that happened was close by, a least within a walking distance. Linear in the way that your life was the same as your father and your children. Nothing changed.
Just like the evolution of man, technology improvements follow an evolutionary progress. New ideas or products are to begin with immature and fragile with slow improvements. Then the progress accelerates until the products become mature and taken for granted. Then the cycle repeats and a new layer of technology is added to the previous. This process is exponential. One such observation of exponential is Moore’s Law.
Any new technology that gets wide acceptance in society needs to be adopted by people. We will explore that type of people are the first to adopt new things, and what types come later.
GLI University hosted Roundtable 2012 in Budapest.
This presentation shows how the online internet is getting more market share and why this is important for lotteries/operators. Great concern is protecting the player and this is why responsible gaming is important. It turns out that responsible gaming is actually easier online than in physical environments like casinos.
This is my lecture at the SpelAkademin in Visby Sweden. In this lecture I talk about how new technologies are changing people's behaviour and what opportunities this offers lotteries.
Innovation is the change in technology. The question is this: how does innovation happen? Many people have believe that new ideas come from brilliant inventors that have lightbulb moments or an epiphany. Greek scholar Archimedes had a Eureka moment, Newton discovered the theory of gravity when the apple fell on his head, and so on. This idea has been popularized, but the truth is quite different. Most discoveries are based on long evaluation - slow hunches, and collaboration.
In this lecture we look at how innovation happens. We look at the slow hunch, the liquid network, and serendipity.
Design patterns are known and tested solutions to common problem. In software engineering we constantly come across similar problems. The same problems or tasks need to be programmed again and again, hence patterns. Design patterns catalog and document these solutions.They are built on industry knowledge of what works and why. We will look at what design patterns are, their history and the structure of documenting patterns.
As an example we look at the Observer pattern.
We will also look at Liskov Substitution Principle and the Open Close Principle, both which are very useful in building enterprise systems. Finally we look at creating objects.
Object Oriented Programming is revisited. It is assumed that students know OO languages so this is more of a review. We will cover concepts such as encapsulation, interfaces and polymorphism. These are important concepts that students must understand in order to write flexible and lasting code. We look at several design principles.
We also look at software design and take an example from a video games.
In this lecture we will also reveal the secret of programming which all good programmers must know.
The Internet grew out of US efforts to build the ARPANET, a network of peer computers built during the cold war. The two major players were military and academia. The network was simple and required no efforts for security or social responsibility. The early Internet community was mainly highly educated and respectable scientist. In the early 1990s the World Wide Web, a hypertext system is introduced, and soon browsers start to appear, leading the commercialization of Net. New businesses emerge and a technology boom known as the dot-com era.
The network, now over 40, is being stretched. Problems such as spam, viruses, antisocial behaviour, and demands for more content are prompting reinvention of the Net and threatening its neutrality. Add to this government efforts to regulate and limit the network.
In this lecture we look at the Internet and the impact of the network. We will also look at the future of the Internet.
In the early days of product development, the technology is inferior and lacking in performance. The focus is very much on the technology itself. The users are enthusiast who like the idea of the product, find use for it, and except the lack of performance. Then as the product becomes more mature, other factors become important, such as price, design, features, portability. The product moves from being a technology to become a consumer item, and even a community.
In this lecture we explore the change from technology focus to consumer focus, and look at why people stand in line overnight to buy the latest gadgets.
History has many examples of powerful companies that seem to be unbeatable. Then in a short time they become irrelevant due to new companies with new ideas. One of the factors in such transformation is technology. Never in history has technological change been so important in building and destroying companies. We look at few examples of successful companies that fail to address the chaning times and become disrupted. We also look at why technology emerges when it does and why some ideas can only be realised when certain conditions are met.
In this first lecture we set the tone for the course and define the themes that we will be looking at.
In this first lecture we look at the state of the industry and specifically the post-pc era that follows the digital decade. The PC is not the center anymore and we as architects need to create solution that are long lasting and usable on any device.
Creating software systems is hard. Fortunately, as system architects we have many methods to build upon and in this lecture we will explore those building blocks. We also look at the evolution of software architectures and the importance of service oriented architecture
Hönnunarmunstur eru aðferðir við að leysa algeng vandamál. En notkun þeirra felst í að takast á við verkefni sem þarf að leysa. Fyrst koma verkefnin og svo finnum við hvaða munstur hentar miðað við þær forsendur sem við höfum. Oft þegar verið er að vinna að lausnum þá er alls ekki hægt að gera allan hugbúnaðinn í einu, heldur þarf að "hakka" suma hluti meðan unnið er í öðru. Til þess að lenda ekki í technical dept þarf að vera með stöðugt refactoring.
Í þessum fyrirlestri skoðum við vandamál og rifjum upp grunnmunstrin (base patterns) sem við kynntumst í L05 Design Patterns. Þá skoðum við hvernig við leysum tengingu við póstþjón.
Sumo Logic QuickStart Webinar - Jan 2016Sumo Logic
QuickStart your Sumo Logic service with this exclusive webinar. At these monthly live events you will learn how to capitalize on critical capabilities that can amplify your log analytics and monitoring experience while providing you with meaningful business and IT insights
Unleash the power of Context and Dependency Injection (CDI) in a JEE container. The slides go over the 2.0 specification and how each part of the specification can be applied. Code for this can be found on GitHub: https://github.com/bpaskin/JavaExamples/tree/master/CDI2.0Examples/src/com/ibm/example/cdi
This document discusses decoupled libraries and frameworks in PHP. It provides background on libraries, frameworks and components. Key principles of decoupled library packages are that they have no dependencies on other packages, encapsulate tests and assets, and are set up for dependency injection rather than static calls. Examples are given of how individual Aura library packages follow these principles, including the Router and Web packages. Limits to full decoupling are noted, as well as the direction of dependencies between packages.
The document describes a .NET template solution architecture that is flexible, maintainable, sustainable, understandable, testable, and allows for easy addition of new features. It recommends layering the solution into projects for the frontend, services, data access, entities/DTOs, repositories, view models, inversion of control, and mapping entities to view models. Each layer has specific responsibilities and dependencies designed to separate concerns and enable loose coupling between layers.
Aspect oriented programming (AOP) allows encapsulation of cross-cutting concerns in separate units called aspects. This modularizes functionality that spans multiple classes. Spring provides AOP support through @AspectJ annotations or XML configuration. Advice like before, after returning, and around intercept method invocations defined by pointcut expressions. This separates concerns and promotes loosely coupled and reusable code.
The document describes ViP2P, a system for distributed data management and querying in peer-to-peer networks using materialized views. It enables peers to pose queries over distributed data by rewriting queries using available views. The querying peer looks up view definitions, rewrites the query into a logical plan based on the views, generates an optimized physical plan, and executes it to return results. The system uses distributed hash tables, third-party libraries, and supports defining, indexing, materializing and querying distributed views across the peer-to-peer network.
The document discusses object-oriented analysis, design, and programming. It covers topics like use cases, conceptual models, classes, objects, encapsulation, inheritance, polymorphism, interfaces, and access modifiers. The analysis process involves modeling system objects and their interactions. Design refines the analysis models and introduces key concepts. Programming implements the design using languages like C# that support object-oriented principles.
The document provides an overview of Apache Eagle, an open source distributed real-time monitoring and alerting engine for Hadoop from eBay. It discusses Eagle's architecture, which includes real-time data collection, a distributed policy engine using stream processing, scalable data storage and querying, and machine learning integration. The document also covers Eagle's ecosystem, how it can be used for security, and integration with tools like Ambari, Docker, and Ranger.
Examiness hints and tips from the trenchesIsmail Mayat
This document provides an overview of tools and techniques for working with the Examine search engine in Umbraco, including:
- Tools like Luke and the Examine Dashboard for debugging indexes.
- Using the GatheringNodeData event to merge fields, add fields like node type aliases, and handle errors during indexing.
- Indexing different media types like PDFs using Tika.
- Techniques for search highlighting, boosting documents, and deploying index changes across environments.
- Faceted search capabilities and using the index as an object database.
The presenter encourages exploring the full capabilities of Examine and provides examples of how to optimize indexing and searching.
Alfresco Business Reporting - Tech Talk Live 20130501Tjarda Peelen
This is the Slide Deck used in Alfresco's Tech Talk Live, May 1, 2013. It featured my Alfresco add-on: Alfresco Business Reporting. The purpose is to the technical 'why' and 'how' of the add-on module, the challenge faced and he solutions designed.
Apache Eagle is a distributed real-time monitoring and alerting engine for Hadoop from eBay. It provides features such as common policies and alerts, metadata classification, and metrics. It has a stream processing engine and uses a distributed policy engine for real-time evaluation based on metadata. It also supports ML-based anomaly detection and integrates with other systems such as Apache Ranger, Splunk, and Docker.
Sumo Logic Quickstart Training 10/14/2015Sumo Logic
QuickStart your Sumo Logic service with this exclusive webinar. At these monthly live events you will learn how to capitalize on critical capabilities that can amplify your log analytics and monitoring experience while providing you with meaningful business and IT insights
The document discusses several design patterns including Singleton, Factory Method, Strategy, and others. It provides descriptions of the patterns, examples of how they can be implemented in code, and discusses how some patterns like Singleton can be adapted for multi-threaded applications. It also briefly introduces the Multiton pattern, which is an extension of Singleton that allows multiple instances associated with different keys.
Spring Data provides abstractions and implementations for accessing relational and NoSQL data stores. It includes modules for specific databases like Spring Data JPA. Repositories provide basic CRUD operations and can define custom query methods. Entities represent database tables with annotations for properties, relationships, and inheritance. The EntityManager manages persistence contexts and entity instances.
Apache Eagle at Hadoop Summit 2016 San JoseHao Chen
Apache Eagle is a distributed real-time monitoring and alerting engine for Hadoop that was created by eBay and later open sourced as an Apache Incubator project. It provides security for Hadoop systems by instantly identifying access to sensitive data, recognizing attacks/malicious activity, and blocking access in real time through complex policy definitions and stream processing. Eagle was designed to handle the huge volume of metrics and logs generated by large-scale Hadoop deployments through its distributed architecture and linear scalability.
Fyrirlestur fyrir Félag tölvunarfræðinga og Verkfræðingafélagið þann 18.05.2022
Nýsköpun er forsenda tækniframfara sem eru forsendur framþróunar. Nýsköpun byrjar yfirleitt smátt og þarf margar ítranir til að virka. Frumkvöðlar sem eru að búa til nýjungar þurfa ekki einungis að glíma við tæknina og takmarkanir hennar, heldur einnig skoðanir og álit samtímamanna sem sjá ekki alltaf tilgang með nýrri tækni. Í þessum fyrirlestri skoðar Ólafur Andri nýsköpun og þær framfarir sem hafa orðið. Einnig skoðar hann hvert tækniframfarir nútímans muni leiða okkur á komandi árum.
Ólafur Andri Ragnarsson er aðjúnkt við Háskólann í Reykjavík og kennir þar námskeið um tækniþróun og hvernig tæknibreytingar hafa áhrif á fyrirtæki. Hann er tölvunarfræðingur (Msc) að mennt frá Oregon University í Bandaríkjanum. Ólafur Andri er frumkvöðull og stofnaði, ásamt fleirum, Margmiðlun og síðar Betware. Þá tók Ólafur Andri þátt í að stofna leikjafyrirtækið Raw Fury AB í Stokkhólmi.
Fyrirlestur haldinn fyrir tæknifaghóp Stjórnvísi þann 13. október 2020.
Undanfarna áratugi höfum við séð gríðalegar framfarir í tækni og nýsköpun á heimsvísu. Þessar framfarir hafa skapað mannkyninu öllu aukna hagsæld. Þrátt fyrir veirufaraldur á heimsvísu eru framfarir ekkert að minnka heldur munu bara aukast næstu árum. Gervgreind, róbotar, sýndarveruleiki, hlutanetið og margt fleira er að búa til nýjar lausnir og ný tækifæri. Framtíðin er í senn sveipuð dulúð og getur verið spennandi og ógnvekjandi í senn. Eina sem við vitum fyrir vissu er að framtíðin verður alltaf betri. Í þessu fyrirlestri ætlar Ólafur Andri Ragnarsson kennari við HR að fjalla um nýjustu tækni og framtíðina.
Technology is one of the factors of change. When new disruptive technology is introduced, it can change industries. We have many examples of that and will start this journey it one of the most important innovation that has come in our lifetimes, the smartphone. We will explore the impact of the smartphone and the fate of existing companies at the time when iPhone, the first smartphone as we know them, was introduced to the world.
We will also look at other examples from history. Then we look at the broader picture, past industrial revolutions and the one that we are experiencing now, the fourth industrial revolution. Specifically we look briefly at the technologies that fuel this revolution, for example artificial intelligence, robotics, drones, internet of things and more.
This document summarizes a lecture on robotics and drones. It discusses the history of robots dating back to ancient times. It also covers modern industrial robots, robotic developments in the 21st century including robots that can see, hear and sense. The document outlines Isaac Asimov's three laws of robotics. It discusses self-driving cars and their levels of automation. Finally, it covers unmanned aerial vehicles including military drones and delivery drones, and concludes that the robot revolution has only just begun.
The normal interaction with computers is with keyboard and a mouse. For display a rectangular somewhat small screen is used with 2D windowing systems. The mouse was invented more the 40 years ago and has been for 20 years dominant input. Now we are seeing new types of input devices. Multi-touch adds new dimensions and new applications. Natural user interfaces or gesture interfaces where people point to drag objects. Computers are also beginning to recognize facial expressions of people, so it knows if you are smiling. Voice and natural language understanding is getting to a usable stage. All this calls all types of new applications.
Displays are getting bigger. What if any surface was a screen? If you could spray the wall with screen? Or have you phone project images to the wall.
This lectures explores some of these new types of interactions with computers and software. It makes the old mouse look old.
Local is the Lo in SoLoMo, the buzz word. Local is not only about location, it's also about your digital track record. Over 70% of Netflix users watch the films recommend. Mining data to understand people's behaviour is getting to be a huge and valuable business. Advertisers see opportunities in getting direct to their target groups. Predictive intelligence is also about where you will be at some time in the future, and where somebody you know will be.
It turns out that Facebook and Google know you better than you think you know yourself. The world is about to get really scary.
Over two billion people signed up for Facebook. This site the most used site for people when using the Internet. People are not watching TV so much anymore - they using Facebook, Youtube and Netflix and number of popular web sites.
Some people denote their time working for others online. What drives people to write an article on Wikipedia? They don´t get paid. Companies are enlisting people to help with innovations and sites such as Galaxy Zoo ask people to help identifying images. And why do people have to film themselves singing when they cannot sing and post the video on Youtube?
In this lecture we talk about how people are using the web to interact in new ways, and doing stuff.
With the computer revolution vast amount of digital data has become available. With the Internet and smart connected product, the data is growing exponentially. It is estimated that every year, more data is generated than all history prior. And this has repeated over several years.
With all this data, it becomes a platform for something new of its own. In this lecture, we look at what big data is and look at several examples of how to use data. There are many well-know algorithms to analyse data, like clustering and machine learning.
After the computing industry got started, a new problem quickly emerged. How do you operate this machines and how to you program them. The development of operating systems was relatively slow compared to the advances in hardware. First system were primitive but slowly got better as demand for computing power increased. The ideas of the Graphical User Interfaces or GUI (Gooey) go back to Doug Engelbarts Demo of the Century. However, this did not have much impact on the computer industry. One company though, Xerox, a photocopy company explored these ideas with Palo Alto Park. Steve Jobs of Apple and Bill Gates of Microsoft took notice and Apple introduced first Apple Lisa and the Macintosh.
In this lecture on we look so lessons for the development of software, and see how our business theories apply.
In this lecture on we look so lessons for the development of algorithms or software, and see how our business theories apply.
In the second part we look at where software is going, namely Artificial Intelligence. Resent developments in AI are causing an AI boom and new AI application are coming all the time. We look at machine learning and deep learning to get an understanding of the current trends.
We are currently living in times of great transformation. We have over the last couple of decade seen the Internet become the most powerful disrupting force in the world, connecting everyone and transforming businesses. Now everyday objects - things we use are getting smart with sensors and software. And they are connecting. What does this mean?
We will see the world become alive. Cars will talk to road sensors that talk to systems that guide traffic. Plants will talk to weather systems that talk to scientists that research climate change. Farming fields will talk to the farming system that talks to robots that do fertilising and harvesting. Home appliances like refrigerators, ovens, coffee machines and microwaves ovens will talk to the home food and cooking system that will inform the store that you are running out butter, cheese, laundry detergent and coffee beans, which will inform the robot driver to get this to your house after consulting your calendar upon when someone is at home.
In this lecture we explore the Internet of Things, IoT.
The Internet grew out of US efforts to build the ARPANET, a network of peer computers built during the cold war. The two major players were military and academia. The network was simple and required no efforts for security or social responsibility. The early Internet community was mainly highly educated and respectable scientist. In the early 1990s the World Wide Web, a hypertext system is introduced, and soon browsers start to appear, leading the commercialization of Net. New businesses emerge and a technology boom known as the dot-com era.
The network, now over 40, is being stretched. Problems such as spam, viruses, antisocial behaviour, and demands for more content are prompting reinvention of the Net and threatening its neutrality. Add to this government efforts to regulate and limit the network.
In this lecture we look at the Internet and the impact of the network. We will also look at the future of the Internet.
The Internet grew out of US efforts to build the ARPANET, a network of peer computers built during the cold war. The two major players were military and academia. The network was simple and required no efforts for security or social responsibility. The early Internet community was mainly highly educated and respectable scientist. In the early 1990s the World Wide Web, a hypertext system is introduced, and soon browsers start to appear, leading the commercialisation of Net. New businesses emerge and a technology boom known as the dot-com era.
The network, now over 40, is being stretched. Problems such as spam, viruses, antisocial behaviour, and demands for more content are prompting reinvention of the Net and threatening its neutrality. Add to this government efforts to regulate and limit the network.
In this lecture we look at the Internet and the impact of the network. We will also look at the future of the Internet.
- Mobile phones are now the most common device in the world, with over 8.5 billion connections globally as of 2017.
- The development of mobile phones was enabled by earlier innovations in electromagnetism and radio in the late 19th century, but mobile phones did not become practical until the 1980s with the invention of the microchip.
- Mobile technology has advanced through generations from analog 1G networks in the 1980s, to digital 2G networks in the 1990s incorporating texting, and 3G packet switched networks in the 2000s enabling more data and applications.
Did you know that the term "Computer" once meant a profession? And what did people or computers actually do? They computed mathematical problems. Some problems were tedious and error prone. And it is not surprising that people started to develop machines to aid in the effort. The first mechanical computers were actually created to get rid of errors in human computation. Then came tabulating machines and cash registers. It was not until telephone companies were well established that computing machines became practical.
First computers were huge mainframes, but soon minicomputers like DEC’s PDP started to appear. The transistor was introduced in 1947, but its usefulness was not truly realized until in 1958 when the integrated circuit was invented. This led to the invention of the microprocessor. Intel, in 1971, marketed the 4004 – and the personal computer revolution started. One of the first Personal Computers was MITS’ Altair. This was a simple device and soon others saw the opportunities.
In this lecture we start our coverage of computing and look at some of the early machines and the impact they had.
Software is changing the way traditional business operate. People now have smartphones in their pockets - a supercomputer that is 25,000 times more powerful and the minicomputers of the 1960s. This is changing people's behaviour and how people shop and use services. The organisational structure created in the 20th century cannot survive when new digital solution are being offered. Software is changing the way traditional business operate. People now have smartphones in their pockets - a supercomputer that is 25,000 times more powerful and the minicomputers of the 1960s. This is changing people's behaviour and how people shop and use services. The organisational structure created in the 20th century cannot survive when new digital solution are being offered. The hierarchical structure of these established companies assumes high coordination cost due to human activity. But when the coordination cost drops
The organisational structure that companies in the 20th century established was based on the fact that employees needed to do all the work. The coordination cost was high due to the effort and cost of employees, housing etc. Now we have software that can do this for use and the coordination cost drops to close-to-zero. Another thing is that things become free. Consider Flickr. Anybody can sign up and use the service for free. Only a fraction of the users get pro account and pay. How can Flickr make money on that? It turns out that services like this can.
Many businesses make money by giving things away. How can that possibly work? The music business has suffered severely with digital distribution of content. Should musicians put all their songs on YouTube? What is the future business model for music?
One of the great irony of successful companies is how easily they can fail. New companies are founded to take advantage of some new technology. They become highly successful and but when the technology shifts, something new comes along, they are unable to adapt and fail. This is the innovator’s dilemma.
Then there are companies that manage to survive. For example, Kodak survived two platform shift, only til fail the third. IBM has survived over 100 years. What do successful companies do differently?
History has many examples of great innovators who had difficult time convincing their contemporaries of new technology. Even incumbent and powerful companies regarded new technologies as inferior and dismissed it as "toys". Then when disruptive technologies take off they often are overhyped and can cause bubbles like the Internet bubble of the late 1990s.
In this lecture we look at some examples of disruptive technologies and the impact they had. We look at the The Disruptive Innovation Theory by Harvard Professor Clayton Christensen.
Technology evolves in big waves that we call revolutions. The first revolution was the Industrial revolution that started in Britain in 1771. Since than we have see more revolutions come and how we are in the fifth. These revolutions follow a similar path. First there is an installation period where the new technologies are installed and deployed, creating wealth to those who were are the right place at the right time. This is followed by a frenzy, where financial markets wants to be apart. The there is crash and turning point, followed by synergy, a golden age.
In 1908, a new technological revolution started. It was the Age of Oil and Automobile. The technology trigger was Henry Ford´s new assembly line technique that allowed the manufacturing of standardized, low cost automobile. This created the car industry and other manufacturing companies. This also created demand for gas thus creating the oil industry. During the Roaring Twenties the stock prices rose to new levels, until a crash and the Great Depression. Only after World War II, came a turnaround point followed by a golden age in the post-war boom.
In this lecture we look at a framework for understanding technological revolutions. There revolutions completely change societies and replace the old with new technologies. We will explore how these revolutions take place. We should now be in the golden age phase.
We also look at generations.
In the early days of product development, the technology is inferior and lacking in performance. The focus is very much on the technology itself. The users are enthusiast who like the idea of the product, find use for it, and except the lack of performance. Then as the product becomes more mature, other factors become important, such as price, design, features, portability. The product moves from being a technology to become a consumer item, and even a community.
In this lecture we explore the change from technology focus to consumer focus, and look at why people stand in line overnight to buy the latest gadgets.
This document summarizes a lecture about the diffusion of innovation. It discusses how new ideas are developed through collaboration and exchange. It also discusses how innovations diffuse slowly at first, gaining momentum over time as they are adopted by pragmatists and conservatives seeking convenient solutions. The rate of adoption follows an S-curve, with innovators and enthusiasts driving early adoption and the mass market adopting later. Customers' motivations for adoption change over time, initially valuing the innovation's benefits and later valuing its functionality. Factors like network effects, convenience, and compatibility influence adoption rates.
Building RAG with self-deployed Milvus vector database and Snowpark Container...Zilliz
This talk will give hands-on advice on building RAG applications with an open-source Milvus database deployed as a docker container. We will also introduce the integration of Milvus with Snowpark Container Services.
Pushing the limits of ePRTC: 100ns holdover for 100 daysAdtran
At WSTS 2024, Alon Stern explored the topic of parametric holdover and explained how recent research findings can be implemented in real-world PNT networks to achieve 100 nanoseconds of accuracy for up to 100 days.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
How to Get CNIC Information System with Paksim Ga.pptxdanishmna97
Pakdata Cf is a groundbreaking system designed to streamline and facilitate access to CNIC information. This innovative platform leverages advanced technology to provide users with efficient and secure access to their CNIC details.
Introducing Milvus Lite: Easy-to-Install, Easy-to-Use vector database for you...Zilliz
Join us to introduce Milvus Lite, a vector database that can run on notebooks and laptops, share the same API with Milvus, and integrate with every popular GenAI framework. This webinar is perfect for developers seeking easy-to-use, well-integrated vector databases for their GenAI apps.
Alt. GDG Cloud Southlake #33: Boule & Rebala: Effective AppSec in SDLC using ...James Anderson
Effective Application Security in Software Delivery lifecycle using Deployment Firewall and DBOM
The modern software delivery process (or the CI/CD process) includes many tools, distributed teams, open-source code, and cloud platforms. Constant focus on speed to release software to market, along with the traditional slow and manual security checks has caused gaps in continuous security as an important piece in the software supply chain. Today organizations feel more susceptible to external and internal cyber threats due to the vast attack surface in their applications supply chain and the lack of end-to-end governance and risk management.
The software team must secure its software delivery process to avoid vulnerability and security breaches. This needs to be achieved with existing tool chains and without extensive rework of the delivery processes. This talk will present strategies and techniques for providing visibility into the true risk of the existing vulnerabilities, preventing the introduction of security issues in the software, resolving vulnerabilities in production environments quickly, and capturing the deployment bill of materials (DBOM).
Speakers:
Bob Boule
Robert Boule is a technology enthusiast with PASSION for technology and making things work along with a knack for helping others understand how things work. He comes with around 20 years of solution engineering experience in application security, software continuous delivery, and SaaS platforms. He is known for his dynamic presentations in CI/CD and application security integrated in software delivery lifecycle.
Gopinath Rebala
Gopinath Rebala is the CTO of OpsMx, where he has overall responsibility for the machine learning and data processing architectures for Secure Software Delivery. Gopi also has a strong connection with our customers, leading design and architecture for strategic implementations. Gopi is a frequent speaker and well-known leader in continuous delivery and integrating security into software delivery.
Securing your Kubernetes cluster_ a step-by-step guide to success !KatiaHIMEUR1
Today, after several years of existence, an extremely active community and an ultra-dynamic ecosystem, Kubernetes has established itself as the de facto standard in container orchestration. Thanks to a wide range of managed services, it has never been so easy to set up a ready-to-use Kubernetes cluster.
However, this ease of use means that the subject of security in Kubernetes is often left for later, or even neglected. This exposes companies to significant risks.
In this talk, I'll show you step-by-step how to secure your Kubernetes cluster for greater peace of mind and reliability.
GraphSummit Singapore | The Art of the Possible with Graph - Q2 2024Neo4j
Neha Bajwa, Vice President of Product Marketing, Neo4j
Join us as we explore breakthrough innovations enabled by interconnected data and AI. Discover firsthand how organizations use relationships in data to uncover contextual insights and solve our most pressing challenges – from optimizing supply chains, detecting fraud, and improving customer experiences to accelerating drug discoveries.
Goodbye Windows 11: Make Way for Nitrux Linux 3.5.0!SOFTTECHHUB
As the digital landscape continually evolves, operating systems play a critical role in shaping user experiences and productivity. The launch of Nitrux Linux 3.5.0 marks a significant milestone, offering a robust alternative to traditional systems such as Windows 11. This article delves into the essence of Nitrux Linux 3.5.0, exploring its unique features, advantages, and how it stands as a compelling choice for both casual users and tech enthusiasts.
Encryption in Microsoft 365 - ExpertsLive Netherlands 2024Albert Hoitingh
In this session I delve into the encryption technology used in Microsoft 365 and Microsoft Purview. Including the concepts of Customer Key and Double Key Encryption.
Removing Uninteresting Bytes in Software FuzzingAftab Hussain
Imagine a world where software fuzzing, the process of mutating bytes in test seeds to uncover hidden and erroneous program behaviors, becomes faster and more effective. A lot depends on the initial seeds, which can significantly dictate the trajectory of a fuzzing campaign, particularly in terms of how long it takes to uncover interesting behaviour in your code. We introduce DIAR, a technique designed to speedup fuzzing campaigns by pinpointing and eliminating those uninteresting bytes in the seeds. Picture this: instead of wasting valuable resources on meaningless mutations in large, bloated seeds, DIAR removes the unnecessary bytes, streamlining the entire process.
In this work, we equipped AFL, a popular fuzzer, with DIAR and examined two critical Linux libraries -- Libxml's xmllint, a tool for parsing xml documents, and Binutil's readelf, an essential debugging and security analysis command-line tool used to display detailed information about ELF (Executable and Linkable Format). Our preliminary results show that AFL+DIAR does not only discover new paths more quickly but also achieves higher coverage overall. This work thus showcases how starting with lean and optimized seeds can lead to faster, more comprehensive fuzzing campaigns -- and DIAR helps you find such seeds.
- These are slides of the talk given at IEEE International Conference on Software Testing Verification and Validation Workshop, ICSTW 2022.
2. Agenda
Base Patterns
– Gateway, Mapper, Layerd Supertype, Separated
Interface, Registry, Value Object, Plugin, Service
Stub, Record Set
From Problem to Patterns
– Using design patterns
4. Gateway (466)
An object that encapsulates access to an external
system or resource
Wrap external APIs into an interface
– API is usually for accessing some external resource
• Examples: JDBC, JDom, financial software
5. Gateway (466)
How It Works
– Create a simple API and use it access the external
API through a Gateway
– All access is easily defined
– Change in the resource does not require changes in
the client software
– Gateways should be simple – complex logic should
not be in the clients of the Gateway
– Gateways can be generated
6. Gateway (466)
When to Use It
– Gateway is useful when accessing external service
– Can be applied with Service Stub (504)
– Clear benefit is that is makes it easy to swap out one
kind of resource for another
7. Mapper (473)
An object that sets up communiction between
two independent objects
Create communication between two systems but
you still need to make them independent
8. Mapper (473)
How it Works
– A Mapper is an insulating layer between subsystems
– It controls the details of communication between them
without either subsystem being aware of it
– Mappers are fairly easy as they are well-defined
– The tricky part is what system invokes them – third
party system or make the Mapper an Observer
When to Use it
– When you want to decouple different parts of a
system
9. Layer Supertype (475)
A type that acts as the supertype
for all types in its layer
Super class that contains common functionality
in a layer
How it works
– Use this pattern when you
have common features
from all objects in a layer
10. Layer Supertype (475)
When to use it
– When you have common features from all objects in a
layer.
Example
– Domain objects can
have a common
superclass for
ID handling
class DomainObject...
private Long ID;
public Long getID()
{
return ID;
}
public void setID(Long ID)
{
this.ID = ID;
}
public DomainObject(Long ID)
{
this.ID = ID;
}
11. Example: Drawing system
Shape class revisited
– All objects in the drawing layer must have an origin (x
and y) and implement Drawable
public abstract class Shape implements Drawable
{
protected int x,y;
}
12. Separated Interface (476)
Defines an interface in a separate
package from its implementation
Decouples parts of a system
– Controls the dependencies between packages
– Implementation can easily be changed
How it works
– Interface and implementation is placed in separate
packages
– Client uses the interface
– Implementation can be determined at configuration
time
13. Separated Interface
Layered System
– Domain layer depends on Data Source layer
– Data Source layer cannot access Domain layer
Data Source Layer
Domain Layer
JDBC
Code
Interface
RowCallBackHandler
processRow(ResultSet rs)
Concreate class
RowCallBackHandler
processRow(ResultSet rs)
implements
Code reading SQL
Execution calls
Separated interface
14. Separated Interface (476)
Implementation is placed in a separate package
Developers of the client
package are responsible for
the interface
15. Separated Interface (476)
Placing the Separated
Interfaced in a
third package
When to use it
– When you need to break a dependency between two
parts of a system
17. Separated Interface (476)
Instantiating the implementation
– User of the interface should not know the
implementation
Solutions
– Use a Factory and Plugin method
– Use Dependency Injection
18. Separated Interface (476)
public interface FeedHandler
{
public void processObject (FeedEntry entry);
}
public class ReaderClient implements FeedHandler
{
...
public ReaderClient()
{
FeedReader reader = ReaderFactory.getFeedReader();
reader.setFeedHandler(this);
reader.read("http://rss.news.yahoo.com/rss/tech");
}
public void processObject(FeedEntry entry)
{
System.out.println(entry);
}
}
Callback
19. Registry (480)
A well-known object that other objects can use
to find common objects and services
A registry is a global object
How It Works
– Object that can easily be accessed at any time
– Only one object available at any time
– Provides services or information
– Can have different scopes
– Usually not mutable data
– Example: System Settings, Loggers
20. Singleton Registry (480)
Only one instance running
When to Use It
– As a last resort
public class Registry
{
private static Registry soleInstance = new Registry();
public static Registry getInstance()
{
return soleInstance;
}
private Registry()
{
}
...
}
Registry registry = Registry.getInstance();
//registry = new Registry (); Does not work
21. Value Object (486)
A small simple object, like money or date
range, whose equality isn’t based on identity
Small and easily created objects that hold and
represent some data
How it works
– Not based on identity
– Equality is based on comparing values of the object
– Can be immutable (example is the Date class)
When to use it
– When you’re basing equality on something other than
identify
22. Value Object (486)
Examples
– Date, Money
class Money...
private long amount;
private Currency currency;
public Money(double amount, Currency currency)
{
this.currency = currency;
this.amount = Math.round(amount * centFactor());
}
...
23. Value Object Example: Date
GregorianCalendar cal = new GregorianCalendar();
cal.set(1865, Calendar.APRIL, 14);
Date d1 = cal.getTime();
cal.set(1963, Calendar.NOVEMBER, 22);
Date d2 = cal.getTime();
System.out.println(d1.equals(d2));
cal.set(1756, Calendar.JANUARY, 27);
Date d3 = cal.getTime();
Date d4 = cal.getTime();
System.out.println(d3.equals(d4));
false
true
24. Plugin (499)
Links classes during configuration
rather than compilation
Use plugin to provide specific implantation
– Plugins implement specific interface use by the client
application code
– Decision at configuration time or run time
– Use factory to load in the plugin
– For example: on plugin for test, another for production
25. Plugin (499)
caller a plugin factory a plugin configuration
getPlugin
lookupPluginByType
new
a plugin
A caller obtains a Plugin implementation of a
separated interface
When to Use It
– Use plugin when you have behavior that requires
different implementations based on runtime
environment
26. Plugin (499)
ReaderClient uses ReaderFactory to get an
interface to FeedReader
reader.properties define the name of the actual
implementation class
ReaderClient ReaderFactory reader.properties
getFeedReader
props.getProperty("reader")
new
FeedReader
27. Plugin (499)
public ReaderClient()
{
FeedReader reader = ReaderFactory.getFeedReader();
...
} public class ReaderFactory
{
public static FeedReader getFeedReader()
{
...
try
{
props.load(new FileInputStream(new File("reader.properties")));
instanceClass = Class.forName(props.getProperty("reader"));
reader = (FeedReader)instanceClass.newInstance();
} ...
return reader;
}
} reader=RssFeedReader
28. Service Stub (504)
Removes dependence upon problematic
services during testing
Enterprise systems often need to access
external system
– Can be out of developers control
29. Service Stub (504)
Service stub provides implementation for
development and testing purposes
– Runs locally and in-memory
– Implements the same interface of the gateway used
to access the real service
When to Use It
– Service stub is useful when dependence on a
particular service is hindering development or testing
– Called “Mock Object” in the extreme programming
world
30. Service Stub Examples
public class ReaderStub extends AbstractFeedReader
{
public void read(String url)
{
feedHandler.processEntry(new FeedEntry("title1", "Bla bla bla"));
feedHandler.processEntry(new FeedEntry("title2", "Bla bla bla"));
feedHandler.processEntry(new FeedEntry("title3", "Bla bla bla"));
}
}
title1
Bla bla bla
title2
Bla bla bla
title3
Bla bla bla
reader=ReaderStub
reader.properties
31. Record Set (508)
An in-memory representation of tabular data
Allows you to access database data from other
objects
– Scroll through a list of data
32. Record Set (508)
How it Works
– Record set are usually provide by database classes
(JDBC or ADO.NET)
– Look exactly like the results of a database query
– Provides abstraction from the database code
When to Use It
– When you need a common way to manipulate data
from a relational database
33.
34. Summary
Base Patterns
– Gateway, Mapper, Layerd Supertype, Separated
Interface, Registry, Value Object, Plugin, Service
Stub, Record Set
Next: From Problem to Patterns
– Using design patterns
36. Question #1
You use this patterns when you need to break
a dependency between two parts of the
system
A) Registry
B) Gateway
C) Separated Interface
D) Plugin
37. Question #2
Intent of a pattern is this: An object that sets
up communication between two objects
A) Gateway
B) Mapper
C) Registry
D) Value Object
38. Question #3
Sketch of a pattern is his
A) Plugin
B) Mapper
C) Registry
D) Service Stub
39. Question #4
Use this pattern when you find that dependence
on a particular service is hindering your
development and testing
A) Mapper
B) Record Set
C) Service Stub
D) Gateway
41. Using Design Patterns
Normally we don’t start with patterns
– We start with problems to solve
– From Problem to Pattern
Must have clear objectives for the design
– The patterns will come as they are needed
Establish Design Principles
– This applies to your application
Remember the separation of concern
42. From Problem to Pattern
How do I reuse common functionality of my
objects?
–Layered Supertype
How do I access an external service without
becoming too dependant on it?
–Gateway
How do I avoid creating unwanted
dependencies?
–Separated Interface
43. From Problem to Pattern
How do I test my client code using a service that
I don’t have access to?
–Service Stub
How do I link to my implementation class using
configuration
–Plugin
How can I keep common object available within
the application
–Registry
44. Refactoring
Design, redesign, refactor
– Make the design as complete as possible
– But be prepared to change design as you code
– Unit tests become very important
Code Smell
– Think of your code as a baby:
“If it smells, change it!”
45. Refactoring
Refactoring is the process of improving design in
little steps at a time
– Minimizes risks – calculated
– Changes are controlled
– Code can improve
– Less likely to smell
46. The Danger
Code Dept
“I’ll fix it later”
The four most dangerous and expensive words in
programming
48. Mail Service
We are building an web application
– One important service is sending messages in email
– We need to access the e-mail service
49. Mail Service
We decide to use JavaMail API
– Problem is that this API is pretty low-level and
complicated
– Lots of “noise” – not good to have the domain
developers worry about that
What Design Pattern can we use here?
50. Mail Service Gateway
We build a simple gateway to handle mail
– Domain developers don’t worry about the service
– We can easily change to a different mail API
51. Gateway (466)
An object that encapsulates access to an external
system or resource
Wrap external APIs into an interface
– API is usually for accessing some external resource
• Examples: JDBC, JDom, financial software
52. MailSender (1/2)
Class that sends the mail
– Method send that takes care of sending the mail
public class MailSender
{
public void send(String from, String to,
String subject, String body)
{
String smtpServer = "mail.ru.is";
try
{
54. MailSender
Name the problem with his class
public class MailSender {
public void send(String from, String to, String subject, String body) {
String smtpServer = "mail.ru.is";
try {
Properties props = System.getProperties();
props.put("mail.smtp.host", smtpServer);
Session session = Session.getDefaultInstance(props, null);
Message msg = new MimeMessage(session);
msg.setFrom(new InternetAddress(from));
msg.setRecipients(Message.RecipientType.TO,InternetAddress.parse(to, false));
msg.setSubject(subject);
msg.setText(body);
msg.setSentDate(new Date());
Transport.send(msg);
} catch (Exception ex) { ex.printStackTrace(); }
}
}
55. MailSender
Problem
– Many parameters instead of an object
– Mail server is hard-coded
– Exception handling is bad
public void send(String from, String to,
String subject, String body)
{
String smtpServer = ”smtp.ru.is";
try
{ ... }
catch (Exception ex)
{
ex.printStackTrace();
}
}
}
56. MailService
Interface for the domain developers
– Program-to-interfaces Principle
– So let MailSender implement this interface
public interface MailService
{
public void send(String from, String to,
String subject, String body);
}
public class MailSender implements MailService
{
public void send(String from, String to,
String subject, String body)
{ ...
57. Testing
Testing MailService and MainSender is easy
public class TestMail
{
public static void main(String[] args)
{
MailService mail = new MailSender();
mail.send("andri@ru.is", // from
"andri@ru.is", // to
"Hallo", // subject
"So does this stuff work"); // body
}
}
59. Testing
What is the problem with clients like this?
public class TestMail
{
public static void main(String[] args)
{
MailService mail = new MailSender();
mail.send("andri@ru.is", // from
"andri@ru.is", // to
"Hallo", // subject
"So does this stuff work"); // body
}
}
60. Improvements
Problem
– MailSender implementation class is exposed to the
domain layer
Solution
– Use the Plugin Pattern
– Create a factory that will read a configuration file
and load the mail implementation class
– Client will use the MailService interface
61. Plugin (499)
Links classes during configuration
rather than compilation
Use plugin to provide specific implantation
– Plugins implement specific interface use by the client
application code
– Decision at configuration time or run time
– Use factory to load in the plugin
• For example: one plugin for test, another for production
62. Factory with a Plugin
Create a MailFactory class
– Loads mail.properties file
– Creates the class specified in the properties file and
returns interface MailService
– Clients use MailService and are not exposed to
particular implementation
– It’s easy to change the properties file
63. Improvements
Problem
– Can we make the loading of properties and class more
generic?
– Other factories might need this functionality also
Solution:
– Create a Layered Supertype
– MailFactory extends Factory
64. Layer Supertype (475)
A type that acts as the supertype
for all types in its layer
Super class that contains common functionality
in a layer
How it works
– Use this pattern when you
have common features
from all objects in a layer
65. Layer Supertype (475)
A type that acts as the supertype
for all types in its layer
Super class that contains common functionality
in a layer
How it works
– Use this pattern when you
have common features
from all objects in a layer
67. Factory
Has two methods
– loadProperties
– loadClass
Exception handling
– Create a new exception class that we will use
– FactoyException
– Log the error
68. FactoryException
Extends Exception
– Checked exception
– Callers must catch this exception or explicitly throw it
public class FactoryException extends Exception
{
public FactoryException(String message)
{
super(message);
}
public FactoryException(String message, Throwable cause)
{
super(message, cause);
}
}
70. Testing Fails
Exception is thrown and message is logged
2.9.2007 16:49:34 is.ru.honn.rubook.factory.Factory loadClass
SEVERE: Factoy: Class 'is.ru.honn.rubook.mail.MailServiceStubx' not found.
71. Testing Fails
Problem
– MailService implementation classes have to
handle FactoryException or pass it on
– Do we want clients to worry about some factory?
Solution
– One solution is to catch FactoryException and
throw unchecked MailService exception
72. MailFactory
public class MailFactory extends Factory
{
public MailService getMailService()
{
MailService service;
try
{
service = (MailService)loadClass(
loadProperties("mail.properties").
getProperty("mail.service.class"));
}
catch(FactoryException fex)
{
throw new MailServiceException ("Unable to send e-mail", fex);
}
return service;
}
}
73. MailServiceException
Extends RuntimeException
– Unchecked exception
– Callers decide if they want to catch it
public class MailServiceException extends RuntimeException
{
public MailServiceException(String message)
{
super(message);
}
public MailServiceException(String message, Throwable cause)
{
super(message, cause);
}
}
74. Testing
Using the MailFactory class
– We can catch the MailServiceException or ignore it
– Notice we have not only abstracted the Mail API but
also the exception handling
public class TestMail
{
public static void main(String[] args)
{
MailFactory mf = new MailFactory();
MailService mail = mf.getMailService();
mail.send("andri@ru.is", "andri@ru.is", "Hello", "Hello");
}
}
75. Improvements
Problem
– Exception handling in our original MailSender is bad
Solution
– Use the MailServiceException
public void send(MailMessage message)
{
try { ... }
catch (Exception ex)
{
String msg = "Sending mail failed: " + ex.getMessage();
logger.severe(msg);
throw new MailServiceException(msg, ex);
}
SEVERE: Sending mail failed: Unknown SMTP host: mail.ru.is
76. Improvements
Problem
– What if we don’t have access to the SMTP server
at this time?
Solution
– Use a Service Stub
– Create the class MailServiceStub that will simply log out
the mail sent
– Could also write in file
77. Service Stub (504)
Removes dependence upon problematic
services during testing
Enterprise systems often need to access
external system
– Can be out of developers control
78. MailServiceStub
public class MailServiceStub implements MailService
{
Logger logger = Logger.getLogger(LogInfo.LOG_NAME);
public void send(String from, String to,
String subject, String body)
{
logger.info("Sending mail from '" + from + "' to '" + to +
"' Subject: '" + subject);
}
}
2.9.2007 16:36:08 is.ru.honn.rubook.mail.MailServiceStub send
INFO: Sending mail from 'andri@ru.is' to 'andri@ru.is' Subject: 'Hello
mail.service.class=is.ru.honn.rubook.mail.MailServiceStub
mail.properties
79. Improvements
Problem
– What if we need to add new parameter?
Solution
– Use an object to group parameters
– Easy to change without changing the interface
public interface MailService {
public void send(String from, String to,
String subject, String body);
}
public interface MailService
{
public void send(MailMessage message);
}
80. MailMessage
Typical Data Transfer Object
public class MailMessage {
private String from;
private String to;
private String subject;
private String body;
public MailMessage(String from, String to,
String subject, String body)
{
this.from = from;
this.to = to;
this.subject = subject;
this.body = body;
}
public String getFrom() { return from; }
public void setFrom(String from) { this.from = from; }
...
81. Improvements
Problem
– The mail server in MailSender is still hardcoded
Solution
– Place in the configuration file
– Let the factory inject the name into the
Mail Service
public interface MailService
{
public void setMailServer(String mailServer);
public void send(MailMessage message);
}
83. New MailFactoy
getMailService injects the name into the service
public class MailFactory extends Factory
{
public MailService getMailService()
{
...
loadProperties("mail.properties");
service = (MailService)loadClass(getProperties().
getProperty("mail.service.class"));
service.setMailServer(getProperties().
getProperty("mail.server")); // injection
return service;
}
}
mail.service.class=is.ru.honn.rubook.mail.MailSender
mail.server=mail.ru.is
84. Improvements
Problem
– loadProperties loads the file each time used
Solution
– Load once then use
public class Factory
{
private Properties properties = new Properties();
protected Properties loadProperties(String filename) throws FactoryException
{ ...
return properties;
}
public Properties getProperties()
{
return properties;
} ...
85. Improvements
Problem
– All mail server implementations must store server name
and set function
– Common functionality in multiple classes
Solution
– Create a Layered Supertype
– Take care of the common functionality
– Make the send method abstract
86. AbstractMailService
Implements MailService
– Provides handling of the mail server property
public abstract class AbstractMailService implements MailService
{
protected String mailServer;
// this is used by the factory to inject
public void setMailServer(String mailServer)
{
this.mailServer = mailServer;
}
public String getMailServer()
{
return mailServer;
}
}
87. MailSender
Extends AbstractMailService
– Does not have to implement the MailServer interface
– Can use the getMailServer method
public class MailSender extends AbstractMailService
{
public void send(MailMessage message)
{
try
{
Properties props = System.getProperties();
props.put("mail.smtp.host", getMailServer());
...
88. Summary
Base Patterns
• Gateway, Mapper, Layerd Supertype, Separated Interface, Registry,
Value Object, Plugin, Service Stub, Record Set
We start with problems to solve
– Then we find the patterns to use
– Must have clear objectives for the design
Beware of code smell
Refactoring is the process of improving design in
little steps at a time
Example case study
– Mail service with a configurable factory