Continuous delivery for containerized applications presents both opportunities and challenges. Container images become the single artifact representing the application build, so metadata must be carefully added to images. Validating non-functional requirements of containerized applications is also important. Developing "mechanical sympathy" by understanding how applications will run in containers can help address issues around resources, security and other operational concerns.
All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk we introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
O'Reilly/Nginx 2016: "Continuous Delivery with Containers: The Trials and Tri...Daniel Bryant
[Many thanks to Nginx for sponsoring this O'Reilly webinar!]
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this webcast we will look at the steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
- The impact of containers on CD
- Creating a container pipeline (including functional and nonfunctional testing)
- Lessons learned the hard way
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" is also available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
GOTO LONDON 2016: Concursus Event sourcing Evolved (Updated)OpenCredo
What if the pitfalls identified in Peter Deutsch’s “eight fallacies of distributed computing” were not inconveniences but opportunities? We present our view of the emerging patterns within distributed systems architecture and argue for a modern semantics of distributed systems based on sympathy with the network. In our approach, event sourcing and stream processing provide the processing model, while microservices and bounded contexts provide the domain model.
We discuss the implementation of Concursus, an open source framework for bringing event sourcing patterns to distributed applications, which represents the evolution of our thinking about event sourcing, based on our practical experience of implementing distributed systems in production.
OOP/MM 2017: "Seven (More) Deadly Sins of Microservices"Daniel Bryant
It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk Daniel will introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include:
Envy - introducing inappropriate intimacy within services by creating a shared domain model, and how many teams deploy and use data stores incorrectly;
Wrath - failing to deal with the inevitable bad things that occur within a distributed system;
Sloth - ignoring the importance of NFRs; and
Lust - embracing the latest and greatest technology without evaluating the impact incurred by these choices.
Haufe #msaday: "Building a Microservice Ecosystem"Daniel Bryant
Microservice platforms are finally becoming a reality: Mesos, Kubernetes, and a whole bunch of PaaS-style offerings are available, but the reality is that these platforms still don’t provide everything you need in order to build a fully functional microservice ecosystem. Come to this session to learn about the essential deployment, orchestration, and glue components that often have to be self-assembled. The presentation begins by looking at deployment techniques and tools and examines where to test (QA, staging, or production), how to test (integration and contracts), and how to separate deployment and release. It then discusses orchestration, configuration, and service discovery. Finally it looks at essential glue such as logging, monitoring, and alerting.
microXchg 2017: "Microservices: The People and Organisational Impact"Daniel Bryant
Microservices are where it's at. Everything is easier to manage when it's micro, right? Micro code bases (less than 10 LOC), micro containers (less than 10Mb), and micro teams (less than one person???). 'Micro' things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. This talk presents some of the challenges the OpenCredo team have seen when implementing microservices within a range of organisations, and we'll suggest tricks and techniques to help you manage your 'micro' teams and the 'macro' level.
Topics covered include: empathy - because understanding others is at the heart of everything you do; leadership - advice on creating shared understanding, conveying strategy, and developing your team; organisational structure - from Zappos' holocracy to MegaOrg's strict hierarchy, from Spotify's squads, chapters and guilds, to BigCorp's command and control. There is a management style for everybody; and more
Devoxx US 2017 "The Seven (More) Deadly Sins of Microservices"Daniel Bryant
There is trouble brewing in the land of microservices – today’s shiny technology is tomorrow’s legacy, and there is concern that we will all be dealing with spaghetti services in 2018…
It is often a sign of an architectural approach’s maturity that, in addition to the emergence of well-established principles and practices, anti-patterns also begin to be identified and classified. In this talk we introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project…
This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include: Pride - selfishly ignoring the new requirements for testing; Envy - introducing inappropriate intimacy within services by creating a shared domain model; Wrath - failing to deal with the inevitable bad things that occur within a distributed system; Sloth - composing services in a lazy fashion, which ultimately leads to the creation of a “Distributed Monolith”; and Lust - embracing the latest, greatest (and costly) technology.
JAXDevOps 2017 "The Seven (More) Deadly Sins of MicroservicesDaniel Bryant
All is not completely rosy in microservice-land. It’s often a sign of an architectural approach’s maturity that anti-patterns begin to be identified and classified alongside well-established principles and practices. Daniel Bryant introduces seven deadly sins from real projects, which left unchecked could easily ruin your next microservices project.
Daniel offers an updated tour for 2016 of some of the nastiest anti-patterns in microservices from several real-world projects he’s encountered as a consultant, providing a series of anti-pattern “smells” you can sniff out and exploring the tools and techniques you need to avoid or mitigate the potential damage.
Topics include:
- Pride: Selfishly building the wrong thing, such as the “Inter-Domain-Enterprise-Application-Service-Bus” or a fully bespoke infrastructure platform
- Envy: Introducing inappropriate intimacy within services by creating a shared “canonical” domain model
- Wrath: Failing to deal with the inevitable bad things that occur within a distributed system
- Sloth: Composing services in a lazy fashion, which ultimately leads to the creation of a “distributed monolith”
- Lust: Embracing the latest and greatest technology without evaluating the operational impact incurred by these choices
All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk we introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
O'Reilly/Nginx 2016: "Continuous Delivery with Containers: The Trials and Tri...Daniel Bryant
[Many thanks to Nginx for sponsoring this O'Reilly webinar!]
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this webcast we will look at the steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
- The impact of containers on CD
- Creating a container pipeline (including functional and nonfunctional testing)
- Lessons learned the hard way
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" is also available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
GOTO LONDON 2016: Concursus Event sourcing Evolved (Updated)OpenCredo
What if the pitfalls identified in Peter Deutsch’s “eight fallacies of distributed computing” were not inconveniences but opportunities? We present our view of the emerging patterns within distributed systems architecture and argue for a modern semantics of distributed systems based on sympathy with the network. In our approach, event sourcing and stream processing provide the processing model, while microservices and bounded contexts provide the domain model.
We discuss the implementation of Concursus, an open source framework for bringing event sourcing patterns to distributed applications, which represents the evolution of our thinking about event sourcing, based on our practical experience of implementing distributed systems in production.
OOP/MM 2017: "Seven (More) Deadly Sins of Microservices"Daniel Bryant
It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk Daniel will introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include:
Envy - introducing inappropriate intimacy within services by creating a shared domain model, and how many teams deploy and use data stores incorrectly;
Wrath - failing to deal with the inevitable bad things that occur within a distributed system;
Sloth - ignoring the importance of NFRs; and
Lust - embracing the latest and greatest technology without evaluating the impact incurred by these choices.
Haufe #msaday: "Building a Microservice Ecosystem"Daniel Bryant
Microservice platforms are finally becoming a reality: Mesos, Kubernetes, and a whole bunch of PaaS-style offerings are available, but the reality is that these platforms still don’t provide everything you need in order to build a fully functional microservice ecosystem. Come to this session to learn about the essential deployment, orchestration, and glue components that often have to be self-assembled. The presentation begins by looking at deployment techniques and tools and examines where to test (QA, staging, or production), how to test (integration and contracts), and how to separate deployment and release. It then discusses orchestration, configuration, and service discovery. Finally it looks at essential glue such as logging, monitoring, and alerting.
microXchg 2017: "Microservices: The People and Organisational Impact"Daniel Bryant
Microservices are where it's at. Everything is easier to manage when it's micro, right? Micro code bases (less than 10 LOC), micro containers (less than 10Mb), and micro teams (less than one person???). 'Micro' things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. This talk presents some of the challenges the OpenCredo team have seen when implementing microservices within a range of organisations, and we'll suggest tricks and techniques to help you manage your 'micro' teams and the 'macro' level.
Topics covered include: empathy - because understanding others is at the heart of everything you do; leadership - advice on creating shared understanding, conveying strategy, and developing your team; organisational structure - from Zappos' holocracy to MegaOrg's strict hierarchy, from Spotify's squads, chapters and guilds, to BigCorp's command and control. There is a management style for everybody; and more
Devoxx US 2017 "The Seven (More) Deadly Sins of Microservices"Daniel Bryant
There is trouble brewing in the land of microservices – today’s shiny technology is tomorrow’s legacy, and there is concern that we will all be dealing with spaghetti services in 2018…
It is often a sign of an architectural approach’s maturity that, in addition to the emergence of well-established principles and practices, anti-patterns also begin to be identified and classified. In this talk we introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project…
This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include: Pride - selfishly ignoring the new requirements for testing; Envy - introducing inappropriate intimacy within services by creating a shared domain model; Wrath - failing to deal with the inevitable bad things that occur within a distributed system; Sloth - composing services in a lazy fashion, which ultimately leads to the creation of a “Distributed Monolith”; and Lust - embracing the latest, greatest (and costly) technology.
JAXDevOps 2017 "The Seven (More) Deadly Sins of MicroservicesDaniel Bryant
All is not completely rosy in microservice-land. It’s often a sign of an architectural approach’s maturity that anti-patterns begin to be identified and classified alongside well-established principles and practices. Daniel Bryant introduces seven deadly sins from real projects, which left unchecked could easily ruin your next microservices project.
Daniel offers an updated tour for 2016 of some of the nastiest anti-patterns in microservices from several real-world projects he’s encountered as a consultant, providing a series of anti-pattern “smells” you can sniff out and exploring the tools and techniques you need to avoid or mitigate the potential damage.
Topics include:
- Pride: Selfishly building the wrong thing, such as the “Inter-Domain-Enterprise-Application-Service-Bus” or a fully bespoke infrastructure platform
- Envy: Introducing inappropriate intimacy within services by creating a shared “canonical” domain model
- Wrath: Failing to deal with the inevitable bad things that occur within a distributed system
- Sloth: Composing services in a lazy fashion, which ultimately leads to the creation of a “distributed monolith”
- Lust: Embracing the latest and greatest technology without evaluating the operational impact incurred by these choices
CraftConf 2017 "Microservices: The Organisational and People Impact"Daniel Bryant
Microservices are where it's at. Everything is easier to manage when it's micro, right? Micro code bases (less than 10 LOC), micro containers (less than 10Mb), and micro teams (less than one person???). 'Micro' things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. This talk presents some of the challenges the OpenCredo team have seen when implementing microservices within a range of organisations, and we'll suggest tricks and techniques to help you manage your 'micro' teams and the 'macro' level.
Topics covered include: empathy - because understanding others is at the heart of everything you do; leadership - advice on creating shared understanding, conveying strategy, and developing your team; organisational structure - from Zappos' holocracy to MegaOrg's strict hierarchy, from Spotify's squads, chapters and guilds, to BigCorp's command and control. There is a management style for everybody; and more
GOTO Chicago/CraftConf 2017 "The Seven (More) Deadly Sins of Microservices"Daniel Bryant
All is not completely rosy in microservice-land. It’s often a sign of an architectural approach’s maturity that anti-patterns begin to be identified and classified alongside well-established principles and practices. Daniel Bryant introduces seven deadly sins from real projects, which left unchecked could easily ruin your next microservices project.
Daniel offers an updated tour of some of the nastiest anti-patterns in microservices from several real-world projects he’s encountered as a consultant, providing a series of anti-pattern “smells” to watch out for and exploring the tools and techniques you need to avoid or mitigate the potential damage.
Topics include:
Pride: the admission of the challenges with testing in a distributed system
Envy: introducing inappropriate intimacy within services by creating a shared “canonical” domain model
Wrath: failing to deal with the inevitable bad things that occur when operating new technologies, both from the people and technical aspects
Sloth: composing services in a lazy fashion, which ultimately leads to the creation of a "distributed monolith”
Lust: embracing the latest and greatest technology without evaluating the operational impact incurred by these choices
JAX DevOps 2018 "Continuous Delivery Patterns for Modern Architectures"Daniel Bryant
Modern software development architecture has almost completed its evolution towards being properly component-based: this can be seen by the mainstream embracing Self Contained Systems (SCS), microservices, and serverless. We all know the benefits this can bring, but there can be many challenges delivering applications built using these styles in a continuous, safe, and rapid fashion.
This talk presents a series of patterns based on real-world experience, which will help architects identify and implement solutions for continuous delivery of contemporary architectures. Key topics and takeaways include:
- Core stages in the component delivery lifecycle: develop, test, deploy, operate and observe
- How contemporary architectures impact continuous delivery
- Modifying the build pipeline for testability and deployability of components (with a hat tip to Jez Humble and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices and serverless components
- Continuous delivery, service contracts and end-to-end validation: The good, bad and ugly
- Lessons learned in the trenches
O'Reilly SACON "Continuous Delivery Patterns for Contemporary Architecture"Daniel Bryant
Last year at this conference we learned from Mark Richards that modern software has almost completed its evolution toward component-based architectures—seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Topics include:
- The core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
- How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
- Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices, and serverless components
- Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
- Validating NFRs within a service pipeline
- Lessons learned in the trenches
Codemotion Rome 2018 "Continuous Delivery with Containers: The Good, the Bad ...Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topic covered include: * The impact of containers on CD * Adding metadata to container images * Validating NFR changes imposed by executing Java applications within a container * Lessons learned the hard way (in production)
Language: English
Level: Intermediate
vJUG24 2017 "Continuous Delivery Patterns for Contemporary Architecture"Daniel Bryant
VJUG24 SESSION: CONTINUOUS DELIVERY PATTERNS FOR THE MODERN JAVA DEVELOPER (I.E. ALL OF US!)
Modern software architecture is evolving towards fully component-based systems, but there can be many challenges in delivering these applications in a continuous, safe and rapid fashion. This talk presents a series of patterns that will help developers implement continuous delivery solutions.
DevOpsNorth 2017 "Seven (More) Deadly Sins of Microservices"Daniel Bryant
All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk Daniel will introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include:
• Envy - introducing inappropriate intimacy within services by creating a shared domain model, and how many teams deploy and use data stores incorrectly;
• Wrath - failing to deal with the inevitable bad things that occur within a distributed system;
• Sloth - ignoring the importance of NFRs; and
• Lust - embracing the latest and greatest technology without evaluating the impact incurred by these choices.
DevOpsCon 2017 "Continuous Delivery with Containers"Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topics covered include: The impact of containers on CD, Adding metadata to container images, Validating NFR changes imposed by executing Java applications within a container, Lessons learned the hard way (in production).
vJUG 2017 "Continuous Delivery with Java and Docker: The Good, the Bad, and t...Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
- The impact of containers on continuous delivery with Java
- The importance of adding metadata to container images
- Validating NFR changes imposed by executing Java applications within a container
- Lessons learned the hard way (in production)
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
AllDayDevOps: "Microservices: The People and Organisational Impact"Daniel Bryant
Microservices are where it’s at. Everything is easier to manage when it’s smaller, right? ‘Micro’ things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. Join this session to learn more.
Microservices are where it’s at. Everything is easier to manage when it’s micro, right? Micro code bases (less than 10 LOC), micro containers (less than 10Mb), and micro teams (less than one person???). ‘Micro’ things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. This talk presents some of the challenges the OpenCredo team have seen when implementing microservices within a range of organisations, and we’ll suggest tricks and techniques to help you manage your ‘micro’ teams and the ‘macro’ level.
Topics covered include: leadership - advice on creating shared understanding, conveying strategy, and developing your team; empathy - because understanding others is at the heart of everything you do; organisational structure - from Zappos’ holocracy to MegaOrg’s strict hierarchy, from Spotify’s squads, chapters and guilds, to BigCorp’s command and control. There is a management style for everybody; and more.
#AATC2017: "Continuous Delivery with Containers: The Trials and Tribulations"Daniel Bryant
Slides from my Agile Alliance Technical Conference talk in Boston, April 2017:
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
The impact of containers on CD
Adding metadata to container images
Validating NFR changes imposed by executing Java applications within a container
Lessons learned the hard way (in production)
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
JAXLondon 2017 "Continuous Delivery with Containers and Java"Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include: the impact of containers on CD; adding metadata to container images; validating NFR changes imposed by executing Java applications within a container; and lessons learned the hard way in production.
A supporting O’Reilly report, “Containerizing Continuous Delivery in Java”, will also be available. This contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
ServerlessConf: Serverless for the Enterprise - Rafal GancarzOpenCredo
As Serverless Computing is gaining more and more interest from individuals and companies small and large, it’s not yet obvious how large-scale, enterprise-grade systems can be delivered using the Serverless Architectures.
In this talk Rafal discusses how common Enterprise specific requirements and challenges can be addressed while building large systems using FaaS/Serverless stack on AWS.
O'Reilly SACON NY 2018 "Continuous Delivery Patterns for Contemporary Archite...Daniel Bryant
Last year at this conference we learned from Mark Richards that modern software has almost completed its evolution toward component-based architectures—seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Topics include:
- The core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
- How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
- Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices, and serverless components
- Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
- Validating NFRs within a service pipeline
Lessons learned in the trenches
Open Source and Content Management (+audio)Matt Hamilton
Open Source solutions are becoming more commonplace in corporate IT, with two thirds of companies using Open Source today or planning to use it soon. We've all heard the hype: cheaper to buy, cheaper to run, cheaper to fix. Using Open Source software reduces your risks. But how does this translate to the world of Content Management?
The advantages of Open Source systems go beyond simple cost savings. Content management by its very nature requires a significant level of customisation and integration to meet business requirements. By not prohibiting the inspection and modification of the source code, Open Source enables a level of flexibility not available with proprietary systems.
Open Source enables you to leverage a culture of trust and openness, rather than secrecy. By having access to the source code, a customer can be safe in the knowledge that everything that the software vendor was intended to deliver can be independently verified.
In this talk you will learn how the Open Source community works, how its distributed nature makes it more resilient, and how you can become a part of it and benefit. We will cover the key criteria to consider when evaluating which Open Source CMS is the right fit for your requirements.
SpringOne Platform 2016
Speaker: Doug Sherman; Principal Engineer, DreamWorks
DreamWorks Animation is a company that has historically thrived on taking advantage of cutting edge technologies and has more currently set its sights on further utilizing Microservices and the Cloud as part of its movie making process. This session will review the efforts that took place in both the initial phases which incorporated targeted parts of the Spring Framework, as well as more current efforts that leveraged Spring projects such as Spring Boot, Spring Data and Spring Cloud. Highlighted throughout the talk will be examples demonstrating the pros and cons of various approaches taken, including the social engineering aspects of changing a movie making culture to fully embrace what it means to adopt a Microservices platform.
DockerCon EU 2018 "Continuous Delivery with Docker and Java"Daniel Bryant
Implementing a continuous delivery (CD) pipeline for Java applications is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying Docker container-based Java applications.
Key takeaways include:
- The impact of using Docker containers on Java and Continuous Delivery
- The benefits and challenges of packaging containerised Java applications
- Options for adding metadata to container images
- Validating nonfunctional/operational requirement changes imposed by executing Java applications within a container
- Lessons learned the hard way (in production, at 3am, with lots of coffee)
EduXFactor presents to you a comprehensive up-to-date DevOps certification program. This course will empower you with job-relevant skills and power you ahead in your career.
With this course, master various aspects of software development, operations, continuous integration, continuous delivery, automated configuration management, test, and deployment using DevOps tools like Git, Docker, Jenkins, Ansible, Kubernetes, Puppet & Nagios..
Packed with hands-on exercise for every module, this course is suitable for software developers, technical project managers, architects, operations support, deployment engineers, IT managers, and development managers.
London Hashicorp Meetup #8 - Testing Programmable Infrastructure By Matt LongOpenCredo
With Hashicorp tools like Terraform, Packer and Vagrant, programmable infrastructure is reaching widespread adoption. However, although automated testing of software is becoming ever more common, the same cannot be said with testing programmable infrastructure. With microservices making our deployments more and more complex, we can no longer afford to ignore this type of testing. This talk will cover some experiences we have had testing the programmable infrastructure of complex applications, especially Terraform, and the lessons we have learned.
Voxxed Bristol 2017 - From C to Q, one event at a time: Event Sourcing illust...OpenCredo
Event Sourcing is becoming a popular persistence pattern. But when to trade simplicity of relational databases for scalability and high throughput? Analysing the rationale behind Event Sourcing and separating Commands from Queries, will help you make an informed decision aware of benefits and risks.
Event Sourcing is becoming a popular persistence pattern for scalable applications, reactive architectures and microservices. The subject is rather new, and we have no well defined, “gang-of-four”-like design patterns yet. Nevertheless, most of the introductory materials imply a particular implementation style. This presentation explains Event Sourcing and CQRS without assuming a particular implementation, to give you the freedom of choosing the pattern most appropriate for your business case. It’s a story, following the much-loved format of a visual picture book. Starting from relational and normalised persistent model, through the issues you face when scaling and moving to asynchronous, distributed application. How to get around these limits with event or command sourcing, why you have to use CQRS and what are your options for queries. The journey ends with benefits, drawbacks and, most importantly, with lessons learned “at the coal face” from real projects.
CraftConf 2017 "Microservices: The Organisational and People Impact"Daniel Bryant
Microservices are where it's at. Everything is easier to manage when it's micro, right? Micro code bases (less than 10 LOC), micro containers (less than 10Mb), and micro teams (less than one person???). 'Micro' things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. This talk presents some of the challenges the OpenCredo team have seen when implementing microservices within a range of organisations, and we'll suggest tricks and techniques to help you manage your 'micro' teams and the 'macro' level.
Topics covered include: empathy - because understanding others is at the heart of everything you do; leadership - advice on creating shared understanding, conveying strategy, and developing your team; organisational structure - from Zappos' holocracy to MegaOrg's strict hierarchy, from Spotify's squads, chapters and guilds, to BigCorp's command and control. There is a management style for everybody; and more
GOTO Chicago/CraftConf 2017 "The Seven (More) Deadly Sins of Microservices"Daniel Bryant
All is not completely rosy in microservice-land. It’s often a sign of an architectural approach’s maturity that anti-patterns begin to be identified and classified alongside well-established principles and practices. Daniel Bryant introduces seven deadly sins from real projects, which left unchecked could easily ruin your next microservices project.
Daniel offers an updated tour of some of the nastiest anti-patterns in microservices from several real-world projects he’s encountered as a consultant, providing a series of anti-pattern “smells” to watch out for and exploring the tools and techniques you need to avoid or mitigate the potential damage.
Topics include:
Pride: the admission of the challenges with testing in a distributed system
Envy: introducing inappropriate intimacy within services by creating a shared “canonical” domain model
Wrath: failing to deal with the inevitable bad things that occur when operating new technologies, both from the people and technical aspects
Sloth: composing services in a lazy fashion, which ultimately leads to the creation of a "distributed monolith”
Lust: embracing the latest and greatest technology without evaluating the operational impact incurred by these choices
JAX DevOps 2018 "Continuous Delivery Patterns for Modern Architectures"Daniel Bryant
Modern software development architecture has almost completed its evolution towards being properly component-based: this can be seen by the mainstream embracing Self Contained Systems (SCS), microservices, and serverless. We all know the benefits this can bring, but there can be many challenges delivering applications built using these styles in a continuous, safe, and rapid fashion.
This talk presents a series of patterns based on real-world experience, which will help architects identify and implement solutions for continuous delivery of contemporary architectures. Key topics and takeaways include:
- Core stages in the component delivery lifecycle: develop, test, deploy, operate and observe
- How contemporary architectures impact continuous delivery
- Modifying the build pipeline for testability and deployability of components (with a hat tip to Jez Humble and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices and serverless components
- Continuous delivery, service contracts and end-to-end validation: The good, bad and ugly
- Lessons learned in the trenches
O'Reilly SACON "Continuous Delivery Patterns for Contemporary Architecture"Daniel Bryant
Last year at this conference we learned from Mark Richards that modern software has almost completed its evolution toward component-based architectures—seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Topics include:
- The core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
- How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
- Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices, and serverless components
- Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
- Validating NFRs within a service pipeline
- Lessons learned in the trenches
Codemotion Rome 2018 "Continuous Delivery with Containers: The Good, the Bad ...Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topic covered include: * The impact of containers on CD * Adding metadata to container images * Validating NFR changes imposed by executing Java applications within a container * Lessons learned the hard way (in production)
Language: English
Level: Intermediate
vJUG24 2017 "Continuous Delivery Patterns for Contemporary Architecture"Daniel Bryant
VJUG24 SESSION: CONTINUOUS DELIVERY PATTERNS FOR THE MODERN JAVA DEVELOPER (I.E. ALL OF US!)
Modern software architecture is evolving towards fully component-based systems, but there can be many challenges in delivering these applications in a continuous, safe and rapid fashion. This talk presents a series of patterns that will help developers implement continuous delivery solutions.
DevOpsNorth 2017 "Seven (More) Deadly Sins of Microservices"Daniel Bryant
All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk Daniel will introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include:
• Envy - introducing inappropriate intimacy within services by creating a shared domain model, and how many teams deploy and use data stores incorrectly;
• Wrath - failing to deal with the inevitable bad things that occur within a distributed system;
• Sloth - ignoring the importance of NFRs; and
• Lust - embracing the latest and greatest technology without evaluating the impact incurred by these choices.
DevOpsCon 2017 "Continuous Delivery with Containers"Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topics covered include: The impact of containers on CD, Adding metadata to container images, Validating NFR changes imposed by executing Java applications within a container, Lessons learned the hard way (in production).
vJUG 2017 "Continuous Delivery with Java and Docker: The Good, the Bad, and t...Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
- The impact of containers on continuous delivery with Java
- The importance of adding metadata to container images
- Validating NFR changes imposed by executing Java applications within a container
- Lessons learned the hard way (in production)
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
AllDayDevOps: "Microservices: The People and Organisational Impact"Daniel Bryant
Microservices are where it’s at. Everything is easier to manage when it’s smaller, right? ‘Micro’ things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. Join this session to learn more.
Microservices are where it’s at. Everything is easier to manage when it’s micro, right? Micro code bases (less than 10 LOC), micro containers (less than 10Mb), and micro teams (less than one person???). ‘Micro’ things may appear to be easier to manage, but there is always a macro context, and working with people and teams is no exception. This talk presents some of the challenges the OpenCredo team have seen when implementing microservices within a range of organisations, and we’ll suggest tricks and techniques to help you manage your ‘micro’ teams and the ‘macro’ level.
Topics covered include: leadership - advice on creating shared understanding, conveying strategy, and developing your team; empathy - because understanding others is at the heart of everything you do; organisational structure - from Zappos’ holocracy to MegaOrg’s strict hierarchy, from Spotify’s squads, chapters and guilds, to BigCorp’s command and control. There is a management style for everybody; and more.
#AATC2017: "Continuous Delivery with Containers: The Trials and Tribulations"Daniel Bryant
Slides from my Agile Alliance Technical Conference talk in Boston, April 2017:
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
The impact of containers on CD
Adding metadata to container images
Validating NFR changes imposed by executing Java applications within a container
Lessons learned the hard way (in production)
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
JAXLondon 2017 "Continuous Delivery with Containers and Java"Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include: the impact of containers on CD; adding metadata to container images; validating NFR changes imposed by executing Java applications within a container; and lessons learned the hard way in production.
A supporting O’Reilly report, “Containerizing Continuous Delivery in Java”, will also be available. This contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
ServerlessConf: Serverless for the Enterprise - Rafal GancarzOpenCredo
As Serverless Computing is gaining more and more interest from individuals and companies small and large, it’s not yet obvious how large-scale, enterprise-grade systems can be delivered using the Serverless Architectures.
In this talk Rafal discusses how common Enterprise specific requirements and challenges can be addressed while building large systems using FaaS/Serverless stack on AWS.
O'Reilly SACON NY 2018 "Continuous Delivery Patterns for Contemporary Archite...Daniel Bryant
Last year at this conference we learned from Mark Richards that modern software has almost completed its evolution toward component-based architectures—seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Topics include:
- The core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
- How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
- Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices, and serverless components
- Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
- Validating NFRs within a service pipeline
Lessons learned in the trenches
Open Source and Content Management (+audio)Matt Hamilton
Open Source solutions are becoming more commonplace in corporate IT, with two thirds of companies using Open Source today or planning to use it soon. We've all heard the hype: cheaper to buy, cheaper to run, cheaper to fix. Using Open Source software reduces your risks. But how does this translate to the world of Content Management?
The advantages of Open Source systems go beyond simple cost savings. Content management by its very nature requires a significant level of customisation and integration to meet business requirements. By not prohibiting the inspection and modification of the source code, Open Source enables a level of flexibility not available with proprietary systems.
Open Source enables you to leverage a culture of trust and openness, rather than secrecy. By having access to the source code, a customer can be safe in the knowledge that everything that the software vendor was intended to deliver can be independently verified.
In this talk you will learn how the Open Source community works, how its distributed nature makes it more resilient, and how you can become a part of it and benefit. We will cover the key criteria to consider when evaluating which Open Source CMS is the right fit for your requirements.
SpringOne Platform 2016
Speaker: Doug Sherman; Principal Engineer, DreamWorks
DreamWorks Animation is a company that has historically thrived on taking advantage of cutting edge technologies and has more currently set its sights on further utilizing Microservices and the Cloud as part of its movie making process. This session will review the efforts that took place in both the initial phases which incorporated targeted parts of the Spring Framework, as well as more current efforts that leveraged Spring projects such as Spring Boot, Spring Data and Spring Cloud. Highlighted throughout the talk will be examples demonstrating the pros and cons of various approaches taken, including the social engineering aspects of changing a movie making culture to fully embrace what it means to adopt a Microservices platform.
DockerCon EU 2018 "Continuous Delivery with Docker and Java"Daniel Bryant
Implementing a continuous delivery (CD) pipeline for Java applications is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying Docker container-based Java applications.
Key takeaways include:
- The impact of using Docker containers on Java and Continuous Delivery
- The benefits and challenges of packaging containerised Java applications
- Options for adding metadata to container images
- Validating nonfunctional/operational requirement changes imposed by executing Java applications within a container
- Lessons learned the hard way (in production, at 3am, with lots of coffee)
EduXFactor presents to you a comprehensive up-to-date DevOps certification program. This course will empower you with job-relevant skills and power you ahead in your career.
With this course, master various aspects of software development, operations, continuous integration, continuous delivery, automated configuration management, test, and deployment using DevOps tools like Git, Docker, Jenkins, Ansible, Kubernetes, Puppet & Nagios..
Packed with hands-on exercise for every module, this course is suitable for software developers, technical project managers, architects, operations support, deployment engineers, IT managers, and development managers.
London Hashicorp Meetup #8 - Testing Programmable Infrastructure By Matt LongOpenCredo
With Hashicorp tools like Terraform, Packer and Vagrant, programmable infrastructure is reaching widespread adoption. However, although automated testing of software is becoming ever more common, the same cannot be said with testing programmable infrastructure. With microservices making our deployments more and more complex, we can no longer afford to ignore this type of testing. This talk will cover some experiences we have had testing the programmable infrastructure of complex applications, especially Terraform, and the lessons we have learned.
Voxxed Bristol 2017 - From C to Q, one event at a time: Event Sourcing illust...OpenCredo
Event Sourcing is becoming a popular persistence pattern. But when to trade simplicity of relational databases for scalability and high throughput? Analysing the rationale behind Event Sourcing and separating Commands from Queries, will help you make an informed decision aware of benefits and risks.
Event Sourcing is becoming a popular persistence pattern for scalable applications, reactive architectures and microservices. The subject is rather new, and we have no well defined, “gang-of-four”-like design patterns yet. Nevertheless, most of the introductory materials imply a particular implementation style. This presentation explains Event Sourcing and CQRS without assuming a particular implementation, to give you the freedom of choosing the pattern most appropriate for your business case. It’s a story, following the much-loved format of a visual picture book. Starting from relational and normalised persistent model, through the issues you face when scaling and moving to asynchronous, distributed application. How to get around these limits with event or command sourcing, why you have to use CQRS and what are your options for queries. The journey ends with benefits, drawbacks and, most importantly, with lessons learned “at the coal face” from real projects.
Haufe #msaday - Seven More Deadly Sins of Microservices by Daniel Bryant OpenCredo
All is not completely rosy in microservice-land. It is often a sign of an architectural approach’s maturity that in addition to the emergence of well established principles and practices, that anti-patterns also begin to be identified and classified. In this talk Daniel will introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project... This talk will take a tour of some of the nastiest anti-patterns in microservices, giving you the tools to not only avoid but also slay these demons before they tie up your project in their own special brand of hell.
Topics covered include:
Envy - introducing inappropriate intimacy within services by creating a shared domain model, and how many teams deploy and use data stores incorrectly;
Wrath - failing to deal with the inevitable bad things that occur within a distributed system;
Sloth - ignoring the importance of NFRs; and
Lust - embracing the latest and greatest technology without evaluating the impact incurred by these choices.
This is an all-new 2016 version of Daniel's popular 'deadly sins talk' that was recently presented at QCon NY. The talk received 94% highest rating, and was the fifth most attended talk at the conference. Daniel plans to continually improve the presentation based on his learnings and attendee feedback.
Slides from Lorenzo's speech at Haufe-Lexware Microservice Architecture Day, in Freiburg. A technology-agnostic point of view about applying Reactive Manifesto good practices to microservices.
QCON London 2017 - Monitoring Serverless Architectures by Rafal GancarzOpenCredo
Serverless architectures are attracting more and more interest from the IT professionals and companies hoping to lower the costs of creating and operating distributed systems without constant worrying about availability, scalability and capacity management. Despite all the attractive properties that serverless architectures offer, such systems still need to be comprehensively monitored to be effectively operated and maintain the expected quality of service and SLAs.
In this talk, I will provide the overview of monitoring capabilities required by system built on the Serverless stack, discuss various AWS services that can be used to deliver such capabilities. I will cover everything from metering and logging to tracing, auditing and alerting.
Additionally, I will share some top tips on how to monitor and optimise the spend on the cloud infrastructure as well as control and adjust provisioned capacity for the resources that use provisioned capacity model, like DynamoDB and Kinesis.
Lastly, I will also offer some suggestions on how to supplement provider’s own solutions with bespoke extensions, built using the Serverless stack, to provide even more comprehensive monitoring.
Haufe #msaday - Building a Microservice Ecosystem by Daniel Bryant OpenCredo
Daniel Bryant's slides from his talk at Haufe Microservices Architecture Day 2016.
Microservice platforms are finally becoming a reality: Mesos, Kubernetes, and a whole bunch of PaaS-style offerings are available, but the reality is that these platforms still don’t provide everything you need in order to build a fully functional microservice ecosystem. Come to this session to learn about the essential deployment, orchestration, and glue components that often have to be self-assembled. The presentation begins by looking at deployment techniques and tools and examines where to test (QA, staging, or production), how to test (integration and contracts), and how to separate deployment and release. It then discusses orchestration, configuration, and service discovery. Finally it looks at essential glue such as logging, monitoring, and alerting.
Evolving Project Management: from the sin to the virtue by Antonio CoboOpenCredo
Slide's from Antonio Cobo's talk at the November Psychology of Agile Scrum meetup. Antonio discusses how the PM role needs to evolve from the classical plan-driven approach to a facilitator role more focused on delivering value. He highlights that in order to improve and evolve, we need to understand our mistakes, and then find the virtues needed to drive our teams to accomplish successfully the company goals altogether.
Haufe #msaday - The Actor model: an alternative approach to concurrency By Lo...OpenCredo
A short introduction to the Actor model, as an alternative approach to concurrent programming from Lorezon Nicora's talk at Haufe Microservices Architecture Day.
High Load Strategy 2016 - Project Management: from Stone Age to DevOps OpenCredo
Antonio Cobo's High Load Strategy conference 2016 talk on project managers and their stages from early days till now with the DevOps movement changing IT organisations.
A Visual Introduction to Event Sourcing and CQRS by Lorenzo NicoraOpenCredo
Slides from Lorenzo's speech at Haufe-Lexware Microservice Architecture Day, in Freiburg. A pictorial introduction to the concepts of Command and Event Sourcing, and CQRS, as persistence model for modern, scalable and distributed applications.
muCon 2016: Authentication in Microservice Systems By David BorsosOpenCredo
Software security is hard. Software security in Microservice Systems is even harder. Microservice-style software architectures have steadily been gaining popularity in recent years. They offer many benefits over traditional monolithic software products, however they also introduce new challenges - one of these being security.
In recent years David has worked on this problem in several independent projects, and this talk will draw on his learnings within the topic of authenticating end-users. David will describe, compare and evaluate several authentication options from the perspective of how secure they are and how well they comply with the qualities of a well-designed microservice system. You will leave the talk with suggested evaluation criteria and guidance for implementation based on their use cases.
Microservices Manchester: Microservices and Macro-Economics - A Shorty Histor...OpenCredo
How did we get to where we are? Why is it now that a micro-services approach to building successful projects is in favour?
In this talk, we look at the evolution of project development methodologies with a view to understanding the origins of Microservices and the developments that lead to the currently popular design approaches.
Indeed, we make a case for the inevitability of Microservices and tie this to the very practical application of understanding how Microservice oriented projects lead to improved business processes, new models of business interaction and ultimately to a reduction in overall project cost.
About Marco Cullen
Marco Cullen is a Senior Consultant for OpenCredo having joined the company in 2014. He works on a number of technical engagements for OpenCredo and has experience working in both India and the UK.
Microservices Manchester: Security, Microservces and Vault by Nicki WattOpenCredo
In this talk, Nicki Watt will initially look to introduce and highlight some of the typical security challenges which engineers may encounter, and need to be aware of, when trying to develop and deploy a microservices-based architecture. The 2nd half of the talk tries to get a bit more practical, and through some examples, looks to demonstrate how a tool like Vault from HashiCorp can be used as part of your overall security toolkit to address some of these challenges.
This talk will not be delving into the depths of cryptography and algorithms, rather it is aimed at highlighting some typical problem areas, and giving practical insight into some of the options which can be used to address them.
About Nicki Watt
Nicki Watt is a Lead Consultant for OpenCredo having joined the company in 2011. Nicki is responsible for both hands on and overall leadership of engagements for OpenCredo. She has experience leading both development and architectural teams across a wide range of industries including enterprise organisations and start ups.
Microservices Manchester: Authentication in Microservice Systems by David BorsosOpenCredo
When implementing applications using a microservice architecture, concerns of authenticating and authorising end-users or other services requires a different approach, especially when scalability and no single points of failure is in mind. I’d like to talk about some “lessons learned” in the past few years and show a few ideas how to deal with these concerns.
About David Borsos
David is a Senior Consultant for OpenCredo having joined the company as a consultant in 2013. David works on a number of technical engagements for OpenCredo and has a several years experience working in the financial industry, developing web-based enterprise applications, mostly of internally used tools that supported the maintenance and operations of a large IT infrastructure.
Spring Boot Microservices vs Akka Actor Cluster OpenCredo
Lorenzo Nicora introduces reactive principles and compares two different approaches to them: a microservice architecture based on Spring Boot and a clustered application using Akka, based on lessons learned from real-world projects. Lorenzo also briefly introduces the Actor programming model and how it differs from other approaches for tackling concurrent and non-blocking programming in Java.
Microservices Manchester: Concursus - Event Sourcing Evolved By Domonic FoxOpenCredo
Concursus is an open source Java 8 framework for CQRS / Event Sourcing applications. At its core, Concursus is: * A programming model that makes it easy to produce and consume events, without generating vast numbers of POJOs. * A data model for event sourcing applications, with Cassandra and Redis event store implementations. In this talk, I’ll introduce the programming model, and show how easy it is to assemble an event-sourcing application using Concursus.
About Domonic Fox
Dominic is a Senior Consultant for OpenCredo, having joined the company in 2013. Formerly a Senior Developer for TIM Group, Dominic is both a proficient Java 8 and Scala developer, and a systems architect specialising in scalable solutions using modern technologies such as Cassandra and Kafka.
Java Memory Consistency Model - concepts and contextTomek Borek
Java Memory Consistency Model is a difficult topic.
It's useful in making sure that multi-threaded programs on multi-threaded cores will interact with each other (and through memory) in a consistent manner.
It's specification is damn hard (even according to folks with lots of concurrent experience, like Doug Lea) to read, understand and routinely follow without error.
This presentation talks about some fallacies surrounding memory model, explains it, offers definitions and reasons for it's existence. It ain't deep, it's more entry level stuff.
OReilly SACON 2016 "A Practical Guide for Continuous Delivery with Containers"Daniel Bryant
Is continuous delivery mainstream? We would all like to think so, but as William Gibson reminds us, “The future is already here—it’s just not evenly distributed.” The large (unicorn) companies have been talking about deploying containerized applications for some time, but the processes, techniques, and technologies involved are not always clear when looking in from the outside. This can make it difficult to emulate their success.
Based on his experience building several Docker-based applications that were deployed to a range of orchestration and scheduling platforms, Daniel Bryant demonstrates how to create a scalable build pipeline that takes a series of Java applications, containerizes them, and deploys them to Docker Swarm.
Example code will be available to download via GitHub, and the examples can be executed locally via Vagrant.
Continuous Delivery with Containers: The Good, the Bad, and the Ugly - Daniel...Codemotion
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topic covered include: * The impact of containers on CD * Adding metadata to container images * Validating NFR changes imposed by executing Java applications within a container * Lessons learned the hard way (in production)
ContainerSched 2017 "Continuous Delivery with Containers: The Good, the Bad, ...Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk you will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
- The impact of containers on CD
- Adding metadata to container images
- Validating NFR changes imposed by executing Java applications within a container
-Lessons learned the hard way (in production)
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
SATURN 2018 "Continuous Delivery with Containers" Extended 90 versionDaniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk, we will look at the high-level steps that are essential for creating an effective pipeline for developing and deploying containerized applications. Topics covered include the impact of containers on CD, adding metadata to a container image, validating NFR changes imposed by executing Java applications within a container, and lessons learned the hard way (in production).
CodeOne SF 2018 "Continuous Delivery with Containers: Lessons Learned"Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can bring additional challenges and requirements. This session looks at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications. Topic covered include the impact of containers on CD, adding metadata to container images, validating NFR changes imposed by executing Java applications within a container, and lessons learned (the hard way) in production. A supporting O’Reilly report, “Containerizing Continuous Delivery in Java,” will be available.
Continuous Delivery with Containers: The Good, the Bad, and the UglyDaniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include: * The impact of containers on CD * Adding metadata to container images * Validating NFR changes imposed by executing Java applications within a container * Lessons learned the hard way (in production)
Although the concepts presented in this talk are agnostic to technology, a supporting O’Reilly report “Containerizing Continuous Delivery in Java” will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
Devoxx 2017 "Continuous Delivery with Containers: The Good, the Bad, and the ...Daniel Bryant
Implementing a continuous delivery (CD) pipeline is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying containerized applications.
Topic covered include:
The impact of containers on Java and Continuous Delivery
Adding metadata to container images
Validating NFR changes imposed by executing Java applications within a container
Lessons learned the hard way (in production)
A supporting O'Reilly report "Containerizing Continuous Delivery in Java" will also be available, and this contains instructions and code for how to create a Jenkins-based continuous delivery pipeline that takes a series of Java applications and containerizes them, ready for functional and nonfunctional testing, and ultimately, deployment.
Microservice platforms are finally becoming a reality: Mesos, Kubernetes, and a whole bunch of PaaS-style offerings are available, but the reality is that these platforms still don’t provide everything you need in order to build a fully functional microservice ecosystem. Come to this session to learn about the essential deployment, orchestration, and glue components that often have to be self-assembled. The presentation begins by looking at deployment techniques and tools and examines where to test (QA, staging, or production), how to test (integration and contracts), and how to separate deployment and release. It then discusses orchestration, configuration, and service discovery. Finally it looks at essential glue such as logging, monitoring, and alerting.
DCEU 18: Continuous Delivery with Docker Containers and Java: The Good, the B...Docker, Inc.
Daniel Bryant - Product Architect, Datawire
Implementing a continuous delivery (CD) pipeline for Java applications is not trivial, and the introduction of container technology to the development stack can introduce additional challenges and requirements. In this talk we will look at the high-level steps that are essential for creating an effective pipeline for creating and deploying Docker container-based Java applications. Key takeaways include: - The impact of using Docker containers on Java and Continuous Delivery - The benefits and challenges of packaging containerised Java applications - Options for adding metadata to container images - Validating nonfunctional/operational requirement changes imposed by executing Java applications within a container - Lessons learned the hard way (in production, at 3am, with lots of coffee)
Building Java applications for the IaaS cloud is easy, right? “Sure, no problem. Just lift and shift,” all the cloud vendors shout in unison. However, the reality of building and deploying cloud applications can often be different. This session introduces lessons learned from the trenches during several years of designing and implementing cloud-based Java applications, which we have codified into our Cloud Developer's “DHARMA” rules: Documented (just enough); Highly cohesive/loosely coupled (all the way down); Automated from code commit to cloud; Resource-aware; Monitored thoroughly; and Antifragile.
This session was presented at JavaOne 2014
vJUG24 2016 "Seven (More) Deadly Sins of Microservice"Daniel Bryant
(Updated for Sept 2016, and Java-themed as this talk was presented as part of the 'Virtual JUG' vJUG24 event on 27th Sept)
There is trouble brewing in the land of microservices – today’s shiny technology is tomorrow’s legacy, and there is concern that we will all be dealing with spaghetti services in 2018…
It is often a sign of an architectural approach’s maturity that, in addition to the emergence of well-established principles and practices, anti-patterns also begin to be identified and classified. In this talk we introduce the 2016 edition of the seven deadly sins that if left unchecked could easily ruin your next microservices project…
This talk will feature as a session in vJUG24, the first 24 hour virtual Java Conference in the World. More information is available at http://virtualjug.com/vJUG24/
JAX London 2014 "Building Java Applications for the Cloud: The DHARMA princip...Daniel Bryant
Building Java applications for the Cloud is easy, right? Perhaps, but if you want to build effective and reliable applications that not only work correctly within the Cloud, but also take advantage of running within this unique environment, then you might be in for a surprise. This talk will introduce lessons learnt over the past several years of designing and implementing successful Cloud-based Java applications which we have codified into our Cloud development ‘DHARMA' principles; Documented (just enough); Highly cohesive / lowly coupled (all the way down); Automated from commit to cloud; Resource aware; Monitored thoroughly; and Antifragile. We will look at these lessons from both a theoretic and practical perspective using several real-world case studies involving a move from JVM-based monolithic applications deployed into a data center on a 'big bang' schedule, to a platform of loosely-coupled components, all being continuously deployed into the Cloud. Topics discussed will include API contracts and documentation, microservices, build and deployment pipelines, Cloud fabric properties, monitoring in a distributed environment, and fault-tolerant design patterns.
JavaOne 2016 "Java, Microservices, Cloud and Containers"Daniel Bryant
Everyone is talking about building “cloud native” Java applications—and taking advantage of microservice architecture, containers, and orchestration/PaaS platforms—but there is surprisingly little discussion of migrating existing legacy (moneymaking) applications. This session aims to address this, and, using lessons learned from several real-world examples, it covers topics such when to rewrite applications (if at all), modeling/extracting business domains, applying the “application strangler” pattern, common misconceptions with “12-factor” application design, and the benefits/drawbacks of container technology.
jSpring 2018 "Continuous Delivery Patterns for Modern Architectures and Java"Daniel Bryant
Modern Java applications are moving towards component-based architectures, as seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Topics include:
– The core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
– How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
– Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
– Commonality between delivery of SCS, microservices, and serverless components
– Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
– Validating NFRs within a service pipeline
– Lessons learned in the trenches
LJC 2015 "The Crafty Consultants Guide to DevOps"Daniel Bryant
Come along and learn how the Crafty Consultant makes his money by consulting craftily in DevOps. We'll see how silos can be broken down by introducing more independent and isolated team, how only idiots automate everything, and why monitoring only provides actionable insight that simply confuses your clients...
...and then we'll look at the real world implementation of DevOps :-) The primary aims of this talk are to introduce the concepts behind the DevOps movement, and we'll do this by debunking all of the Crafty Consultant's advice. We'll cover the drivers of breaking down silos (in business and in tech), the benefits of automation (especially with provisioning and configuring infrastructure), and the power that monitoring provides (particularly when deploying to the cloud, or implementing a microservice architecture).
deliver:Agile 2018 "Continuous Delivery Patterns for Modern Architectures"Daniel Bryant
Modern software has almost completed its evolution toward component-based architectures—seen in the mainstream embrace of self-contained systems (SCS), microservices, and serverless architecture. We all know the benefits of component-based architectures, but there are also many challenges to delivering such applications in a continuous, safe, and rapid fashion. Daniel Bryant shares a series of patterns to help you identify and implement solutions for continuous delivery of contemporary service-based architectures.
Learning Outcomes:
- Identify core stages in the component delivery lifecycle: Develop, test, deploy, operate, and observe
- How contemporary architectures impact continuous delivery and how to ensure that this is factored into the design
- Modifying the build pipeline to support testability and deployability of components (with a hat tip to Jez Humble’s and Dave Farley’s seminal work)
- Commonality between delivery of SCS, microservices, and serverless components
- Continuous delivery, service contracts, and end-to-end validation: The good, the bad, and the ugly
- Validating NFRs within a service pipeline
- Lessons learned in the trenches
Webinar - Design Thinking for Platform EngineeringOpenCredo
Design Thinking is revolutionising the delivery of next-level digital services with best-of-breed product design and user interface principles ensuring close alignment with users and making services a joy to use.
While much of this success has been in the delivery of customer-facing services, there is untapped potential when it comes to delivering frictionless experiences for the internal users of your infrastructure services – promising business value through increased productivity and reduced frustration in your development and operations teams.
Check out the slides from our webinar on approaching platform engineering with a design thinking mindset.
MuCon 2019: Exploring Your Microservices Architecture Through Network Science...OpenCredo
Your microservice system has been up and running for a while. You know you’ve diligently employed every ounce of your experience and knowledge over time to design a sensible application architecture, with hopefully sensible boundaries. But time is now throwing new questions your way: Are my boundaries still sensible?
Have any anti-patterns crept in, do I have the dreaded distributed monolith?
This talk explores how network science techniques can be applied to help gain insight into, and explore questions about your microservices architecture.
Goto Chicago; Journeys To Cloud Native Architecture: Sun, Sea And Emergencies...OpenCredo
Many businesses want to embrace modern business practices by delivering projects quickly and scaling faster. For this, adopting a Cloud Native mindset and architecture makes sense but is not a simple magic carpet ride.
In this talk, Nicki Watt from OpenCredo will share the realities of making that journey for a number of clients. Far from being a smooth journey to the promised land, you will learn about the numerous detours, bumps and challenges encountered along the way.
Microservices, Kubernetes, Success, but also Bandages and Crutches; This talk is for you if you want to gain some pragmatic insight into what is entailed with such endeavors.
Mucon 2018: Heuristics for Identifying Microservice Boundaries By Erich Eichi...OpenCredo
When identifying microservice boundaries, it is not enough to consider domains only. Other forces like organisational communication structures, and time, strongly suggest that you also should include other criteria in your considerations. Based on real-world experience of numerous projects, this talk takes a pragmatic walk and explores some of these other heuristics which should also be shaping your microservice decomposition thinking. These considerations may not on the surface seem that obvious, but if ignored, can just as easily lead to project failure. So whether you’ve already been through a painful project which tried to decompose boundaries by the book and failed, or you’re looking for some insight into other considerations often not spoken about, this talk is for you.
Journeys To Cloud Native Architecture: Sun, Sea And Emergencies - Nicki WattOpenCredo
For many businesses looking to embrace modern business practices, deliver and scale faster, adopting a Cloud Native mindset and architecture makes sense. In this talk Nicki Watt, from OpenCredo, will explore the realities of making that journey for a number of clients. Far from being a smooth journey to the promised land, during this talk you will also learn about the numerous detours, bumps and challenges encountered along the way. Microservices, Kubernetes, Success, but also Bandages and Crutches; This talk is for you if you want to gain some pragmatic insight into what is entailed with such endeavours.
Machine Learning Game Changer for IT - Maartens LourensOpenCredo
In this talk Senior Consultant Maartens Lourens introduces machine learning in a pragmatic way. He aims to make it easy to understand the basic Machine Learning process involved by leveraging only the essential tools and libraries required.
Kafka Summit 2018: A Journey Building Kafka Connectors - Pegerto FernandezOpenCredo
These slides are from Pegerto's talk at the London Kafka Summit 2018.
As Kafka keeps rising in popularity, people are increasingly adopting it as a backbone to store and process large streams of immutable events (Event Streaming as the Source of Truth). Also, we need to maintain integration between new data sources and the existing IT systems, as well as evaluate and use new technologies to analyse the captured events. We can observe this trend by the growing number of Kafka connectors. In this talk we focus on the Kafka Connect architecture and the practicalities around building a connector. Not all data sources are created equal and different scenarios require different approaches.
Having assisted customers develop their own connectors to integrate with a number of different data end points, this talk will dive under the hood and look at:
Key patterns to handle different loads across the Kafka connect distributed framework.
Impact of different offset management strategies on message reliability.
Challenges and pitfalls to be aware of.
Using existing connectors as examples, as well as sample connector code, this pragmatic talk aims to deliver practical insight into this process. If you are a Kafka enthusiast looking to develop a better understanding of existing connectors, or contribute to new ones, this talk is for you.
MuCon 2017: A not So(A) Trivial Question by Tareq AbedrabboOpenCredo
It has been said that “Microservices is SOA done right”. But really, what’s the difference between SOA and microservices and why is this question fundamental and has implications that could go beyond a potentially amusing twitter debate?
Microservices have been around for a few years now. Many organisations with large and complicated systems that would truly benefit from introducing microservices can not do so in a vacuum; they are often operating in a context that has been heavily influenced by the SOA movement - for better or worse. This influence can often be easily discerned by existing technical choices, but what is less obvious but more important is the conceptual and architectural influence that the SOA approach is still exerting on how microservices systems even when technical legacy is not an issue.
This talk is based on 4 years and a few microservices project that Tareq has been directly involved in at different stages of maturity. Tareq will share with you some fundamental differences between SOA and microservices, and following that you will learn a number of pragmatic lessons and simple design recommendations that hopefully help bridge the gap between the reality of organisations trying to adopt microservices today and the bleeding edge of theory and technology. Many of these lessons can help you design and build better microservices architectures today.
DevOpsCon Berlin 2017: Project Management from Stone Age to DevOps By Antoni...OpenCredo
The DevOps movement is gradually changing IT organisations. Project managers are often forgotten, but they also need to change. Are project managers ready for the DevOps change? In this talk we will cover the changes project managers are experiencing, first with Agile and now with DevOps.
Hashidays London 2017 - Evolving your Infrastructure with Terraform By Nicki ...OpenCredo
So you are using Terraform to manage your infrastructure, fantastic! However have you ever accidentally destroyed your production setup? Or managed to change some part of your infrastructure you were not expecting to?
This talk explores some common pain points experienced by users on different parts of their Terraform journey and provides insight into how you can evolve your Terraform setup to manage and address these challenges.
Succeeding with DevOps Transformation - Rafal GancarzOpenCredo
Many organisations are interested in adopting DevOps culture and practices but quite often they face some serious challenges after starting a DevOps transformation programme. These problems can be mitigated if organisations are well prepared for what’s likely to happen when their existing processes and culture are being altered during the DevOps transformation effort.
This talk aims to explore the common problem areas that can impact the success of the DevOps transformation, and will provide practical advice for dealing with these based on experiences from our past engagements. It will offer some insight into how organisations can prepare and manage the transformation programme, track and report the progress, and finally, ensure that the desired business outcomes are achieved.
The world of cloud computing is on a verge of revolution, the Serverless revolution. With the advent of Function as a Service capabilities offered by the major cloud providers, the architectures we will be building in the future are going to be very different from those you are familiar with today.
In this talk I will introduce the core concepts around Serverless/FaaS and describe some archirectural and operational aspects of distributed systems built on top the Serverless stack. I will also present some experiences, challenges faced and lessons learned from the Serverless project using AWS cloud platform.
ThingMonk 2016 - Concursus Event sourcing for the IOT By Tareq Abedrabbo & Do...OpenCredo
What if the pitfalls identified in Peter Deutsch’s “eight fallacies of distributed computing” were not inconvenience's but opportunities? We present our view of the emerging patterns within distributed systems architecture and argue for a modern semantics of distributed systems based on sympathy with the network. In our approach, event sourcing and stream processing provide the processing model, while microservices and bounded contexts provide the domain model. We discuss the implementation of Concursus, an open source framework for bringing event sourcing patterns to distributed applications, which represents the evolution of our thinking about event sourcing, based on our practical experience of implementing IoT systems in production.
Essentials of Automations: Optimizing FME Workflows with ParametersSafe Software
Are you looking to streamline your workflows and boost your projects’ efficiency? Do you find yourself searching for ways to add flexibility and control over your FME workflows? If so, you’re in the right place.
Join us for an insightful dive into the world of FME parameters, a critical element in optimizing workflow efficiency. This webinar marks the beginning of our three-part “Essentials of Automation” series. This first webinar is designed to equip you with the knowledge and skills to utilize parameters effectively: enhancing the flexibility, maintainability, and user control of your FME projects.
Here’s what you’ll gain:
- Essentials of FME Parameters: Understand the pivotal role of parameters, including Reader/Writer, Transformer, User, and FME Flow categories. Discover how they are the key to unlocking automation and optimization within your workflows.
- Practical Applications in FME Form: Delve into key user parameter types including choice, connections, and file URLs. Allow users to control how a workflow runs, making your workflows more reusable. Learn to import values and deliver the best user experience for your workflows while enhancing accuracy.
- Optimization Strategies in FME Flow: Explore the creation and strategic deployment of parameters in FME Flow, including the use of deployment and geometry parameters, to maximize workflow efficiency.
- Pro Tips for Success: Gain insights on parameterizing connections and leveraging new features like Conditional Visibility for clarity and simplicity.
We’ll wrap up with a glimpse into future webinars, followed by a Q&A session to address your specific questions surrounding this topic.
Don’t miss this opportunity to elevate your FME expertise and drive your projects to new heights of efficiency.
Transcript: Selling digital books in 2024: Insights from industry leaders - T...BookNet Canada
The publishing industry has been selling digital audiobooks and ebooks for over a decade and has found its groove. What’s changed? What has stayed the same? Where do we go from here? Join a group of leading sales peers from across the industry for a conversation about the lessons learned since the popularization of digital books, best practices, digital book supply chain management, and more.
Link to video recording: https://bnctechforum.ca/sessions/selling-digital-books-in-2024-insights-from-industry-leaders/
Presented by BookNet Canada on May 28, 2024, with support from the Department of Canadian Heritage.
GraphRAG is All You need? LLM & Knowledge GraphGuy Korland
Guy Korland, CEO and Co-founder of FalkorDB, will review two articles on the integration of language models with knowledge graphs.
1. Unifying Large Language Models and Knowledge Graphs: A Roadmap.
https://arxiv.org/abs/2306.08302
2. Microsoft Research's GraphRAG paper and a review paper on various uses of knowledge graphs:
https://www.microsoft.com/en-us/research/blog/graphrag-unlocking-llm-discovery-on-narrative-private-data/
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Epistemic Interaction - tuning interfaces to provide information for AI supportAlan Dix
Paper presented at SYNERGY workshop at AVI 2024, Genoa, Italy. 3rd June 2024
https://alandix.com/academic/papers/synergy2024-epistemic/
As machine learning integrates deeper into human-computer interactions, the concept of epistemic interaction emerges, aiming to refine these interactions to enhance system adaptability. This approach encourages minor, intentional adjustments in user behaviour to enrich the data available for system learning. This paper introduces epistemic interaction within the context of human-system communication, illustrating how deliberate interaction design can improve system understanding and adaptation. Through concrete examples, we demonstrate the potential of epistemic interaction to significantly advance human-computer interaction by leveraging intuitive human communication strategies to inform system design and functionality, offering a novel pathway for enriching user-system engagements.
State of ICS and IoT Cyber Threat Landscape Report 2024 previewPrayukth K V
The IoT and OT threat landscape report has been prepared by the Threat Research Team at Sectrio using data from Sectrio, cyber threat intelligence farming facilities spread across over 85 cities around the world. In addition, Sectrio also runs AI-based advanced threat and payload engagement facilities that serve as sinks to attract and engage sophisticated threat actors, and newer malware including new variants and latent threats that are at an earlier stage of development.
The latest edition of the OT/ICS and IoT security Threat Landscape Report 2024 also covers:
State of global ICS asset and network exposure
Sectoral targets and attacks as well as the cost of ransom
Global APT activity, AI usage, actor and tactic profiles, and implications
Rise in volumes of AI-powered cyberattacks
Major cyber events in 2024
Malware and malicious payload trends
Cyberattack types and targets
Vulnerability exploit attempts on CVEs
Attacks on counties – USA
Expansion of bot farms – how, where, and why
In-depth analysis of the cyber threat landscape across North America, South America, Europe, APAC, and the Middle East
Why are attacks on smart factories rising?
Cyber risk predictions
Axis of attacks – Europe
Systemic attacks in the Middle East
Download the full report from here:
https://sectrio.com/resources/ot-threat-landscape-reports/sectrio-releases-ot-ics-and-iot-security-threat-landscape-report-2024/
UiPath Test Automation using UiPath Test Suite series, part 3DianaGray10
Welcome to UiPath Test Automation using UiPath Test Suite series part 3. In this session, we will cover desktop automation along with UI automation.
Topics covered:
UI automation Introduction,
UI automation Sample
Desktop automation flow
Pradeep Chinnala, Senior Consultant Automation Developer @WonderBotz and UiPath MVP
Deepak Rai, Automation Practice Lead, Boundaryless Group and UiPath MVP
Search and Society: Reimagining Information Access for Radical FuturesBhaskar Mitra
The field of Information retrieval (IR) is currently undergoing a transformative shift, at least partly due to the emerging applications of generative AI to information access. In this talk, we will deliberate on the sociotechnical implications of generative AI for information access. We will argue that there is both a critical necessity and an exciting opportunity for the IR community to re-center our research agendas on societal needs while dismantling the artificial separation between the work on fairness, accountability, transparency, and ethics in IR and the rest of IR research. Instead of adopting a reactionary strategy of trying to mitigate potential social harms from emerging technologies, the community should aim to proactively set the research agenda for the kinds of systems we should build inspired by diverse explicitly stated sociotechnical imaginaries. The sociotechnical imaginaries that underpin the design and development of information access technologies needs to be explicitly articulated, and we need to develop theories of change in context of these diverse perspectives. Our guiding future imaginaries must be informed by other academic fields, such as democratic theory and critical theory, and should be co-developed with social science scholars, legal scholars, civil rights and social justice activists, and artists, among others.
Slack (or Teams) Automation for Bonterra Impact Management (fka Social Soluti...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on the notifications, alerts, and approval requests using Slack for Bonterra Impact Management. The solutions covered in this webinar can also be deployed for Microsoft Teams.
Interested in deploying notification automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
How world-class product teams are winning in the AI era by CEO and Founder, P...
O'Reilly 2016: "Continuous Delivery with Containers: The Trials and Tribulations" By Daniel Bryant
1. Continuous Delivery for Containerized Applications:
The Trials and Tribulations
Daniel Bryant
@danielbryantuk
2. Setting the scene…
• Continuous delivery is a large topic
• Focusing on the process and tooling
• No live coding today
• Mini-book contains more details
• “Building a CD pipeline” by Adrian and Kevin
20/12/2016 @danielbryantuk
3. TL;DR – Containers and CD
• Container image becomes the build pipeline ‘single binary’
• Adding metadata to containers images is vital
• Must validate container constraints (NFRs)
• Cultivate containerised ‘mechanical sympathy’
20/12/2016 @danielbryantuk
4. @danielbryantuk
• Chief Scientist at OpenCredo, CTO at SpectoLabs
• Agile, architecture, CI/CD, DevOps
• Java, Go, JS, microservices, cloud, containers
• Leading change through the application of technology and teams
20/12/2016 @danielbryantuk
6. Continuous Delivery
• Produce valuable and robust software in short cycles
• Optimising for feedback and learning
• Not (necessarily) Continuous Deployment
20/12/2016 @danielbryantuk
7. Creation of a build pipeline is mandatory for continuous delivery
20/12/2016 @danielbryantuk
15. Make your dev environment like production
• Develop locally or copy/code in container
• Use base images from production
• Must build/test containers locally
• Perform (at least) happy path tests
• All tests should be runnable locally
20/12/2016 @danielbryantuk
16. Lesson learned: Dockerfile content is super important
• OS choice
• Configuration
• Build artifacts
• Exposing ports
• Java
• JDK vs JRE and Oracle vs OpenJDK
• Golang
• Statically compiled binary
• Python
• Virtualenv
20/12/2016 @danielbryantuk
17. Please talk to the sysadmin people:
Their operational knowledge is invaluable
20/12/2016 @danielbryantuk
18. Different prod and test containers?
• Create “test” version of container
• Full OS (e.g. Ubuntu)
• Test tools and data
• Easy to see app/configuration drift
• Use test sidecar containers instead
• ONTEST proposal by Alexi Ledenev
20/12/2016 @danielbryantuk
http://blog.terranillius.com/post/docker_testing/
20. Building images with Jenkins
• My report covers this
• Build as usual…
• Build Docker Image
• Cloudbees Docker Build and Publish Plugin
• Push image to registry
20/12/2016 @danielbryantuk
21. Storing in an image registry (DockerHub)
20/12/2016 @danielbryantuk
22. Lesson learned: Metadata is valuable
• Application metadata
• Version / GIT SHA
• Build metadata
• Build date
• Image name
• Vendor
• Quality metadata
• QA control
• Security audited etc
20/12/2016 @danielbryantuk
23. Metadata – Beware of “latest” Docker Tag
• Beware of the ‘latest’ Docker tag
• “Latest” simply means
• the last build/tag that ran without
a specific tag/version specified
• Ignore “latest” tag
• Version your tags, every time
• Danielbryantuk/test:2.4.1
20/12/2016 @danielbryantuk
24. Metadata - Adding Labels at build time
• Docker Labels
• Add key/value data to image
20/12/2016 @danielbryantuk
25. Metadata - Adding Labels at build time
• Microscaling Systems’ Makefile
• Labelling automated builds on
DockerHub (h/t Ross Fairbanks)
• Create file /hooks/build
• label-schema.org
• microbadger.com
20/12/2016 @danielbryantuk
26. Metadata - Adding Labels at runtime
20/12/2016 @danielbryantuk
$ docker run -d --label
uk.co.danielbryant.lbname=frontdoor nginx
• Can ’docker commit’, but creates new image
• Not possible to update running container
• Docker Proposal: Update labels #21721
39. Containerise an existing (monolithic) app?
• For
• We know the monolith well
• Allows homogenization of the
pipeline and deployment platform
• Can be a demonstrable win for
tech and the business
• Against
• Can be difficult (100+ line scripts)
• Often not designed for operation
within containers, nor cloud native
• Putting lipstick on a pig?
20/12/2016 @danielbryantuk
41. Key lessons learned
• Conduct an architectural review
• Architecture for Developers, by Simon Brown
• Architecture Interview, by Susan Fowler
• Look for data ingress/egress
• File system access
• Support resource constraints/transience
• Optimise for quick startup and shutdown
• Evaluate approach to concurrency
• Store configuration (secrets) remotely
20/12/2016 @danielbryantuk
43. Microservices…
Containers and microservices are
complementary
Testing and deployment change
20/12/2016 @danielbryantuk
https://specto.io/blog/recipe-for-designing-building-testing-microservices.html
51. In summary
• Continuous delivery is vitally important in modern architectures/ops
• Container images must be the (single) source of truth within pipeline
• Mechanical sympathy is important (assert properties in the pipeline)
• We’re now bundling more responsibility into our artifact (e.g. an OS)
• Not all developers are operationally aware
• The tooling is now becoming stable/mature
• We need to re-apply old CD practices with new technologies/tooling
20/12/2016 @danielbryantuk