Friends don’t let friends remain afraid to change code—and legacy code is code that we’re afraid to change. Join J. B. Rainsberger to explore every aspect of surviving legacy code, including techniques for managing the design, project risks, and the people involved. When you leave this workshop, you’ll have a bag of tricks that you can use to make progress without introducing too much chaos into your project. You might not be able to turn your legacy code base into paradise, but you can survive it. If nothing else, you’ll know what not to do the next time you have a chance to start a new code base.
Interest in native programming languages has been on the rise, and with it an interest in what the new C++ can offer. Much C++ code has its origins in pre-standard systems and styles. The modern C++ era arrived with the STL, the C++98 standard and a host of techniques and guidelines. Unfortunately, it also came with a lot of complexity of techniques, syntactic noise and unfulfilled potential. C++11 represented a fundamental shift in both language features and supported programming styles, a postmodern tradition continued in the C++14 and C++17 standards.This one-day tutorial explores language and library features and the implications for programming style, everything from code that is easier on the eye to code that is easier on the processor, from cleaner object-oriented programming to a functional-programming style, from event-driven to concurrent code. Some familiarity with C++ is assumed, but deep, metal-hugging knowledge is not required.
You’ve tried and tried to convince people of your position. You’ve laid out your logical arguments on impressive PowerPoint slides—but you are still not able to sway them. Cognitive scientists understand that the approach you are taking is rarely successful. Often you must speak to others’ subconscious motivators rather than their rational, analytic side. Linda Rising shares influence strategies that you can use to more effectively convince others to see things your way. These strategies take advantage of a number of hardwired traits: “liking”—we like people who are like us; “reciprocity”—we repay in kind; “social proof”—we follow the lead of others similar to us; “consistency”—we align ourselves with our previous commitments; “authority”—we defer to authority figures; and “scarcity”—we want more of something when there is less to be had. Learn how to build on these traits as a way of bringing others to your side. Use this valuable toolkit in addition to the logical left-brain techniques on which we depend.
Workshop covers RavenDB’s core concepts, getting comfortable with its API, learning how to build and customize indexes and how to correctly model data for use in a document database. After familiarity with basics we will expand and tackle grok Map⁄Reduce, Multi–maps and other advanced usages of indexes, learn how to extend RavenDB and the various options of scaling out.
RavenDB in production and what options there are for monitoring what it’s doing.
Go beyond the hype and build a solid foundation of theory and practice with this workshop on SOA development.
Join Jimmy and Adam for a two-day deep dive covering architectural topics like:
– UI decomposition- Data ownership across the enterprise- How to choose NOSQL databases for your services.
You’ll also learn the nitty-gritty details of building production-ready systems including:
– Fault tolerance – HTTP and queues- Reliable integration with 3rd party systems- Scalability, high availability & monitoring
Finally, get some hands-on experience in SOA development by building:
– Scalable command-processing endpoints- Publish/subscribe event-processing interactions- Long-running multi-stage business processes and policies
Table of contents
– Introduction to boundaries and data ownership
– Microservices and vertical slices
– Services UI composition
– Introduction to pub/sub as a communication pattern
– Reliable messaging concepts
– How to reduce coupling across microservices
– Introduction to commands as a communication pattern
– Anti-corruption components & reliable integration with 3rd party systems
– IT/ops and server side data-composition when integrating with 3rd parties
– Long running business transactions
– Saga patterns overview
We’ll understand service oriented architecture concepts, and DDD concepts such as bounded contexts and data ownership.
We’ll apply those concepts to build a simple, yet fully functional, order management system sample with a microservices architecture, using patterns such as command processing, pub/sub and long-running sagas.
Senior developers, tech leads, and architects will benefit most from this workshop.
Participants are requested to bring a Windows laptop with Visual Studio 2017 or Visual Studio 2015 Update 3 and to follow the full set up instructions at least one week before the workshop, available at https://github.com/Particular/Workshop.Microservices/blob/master/README.md
Would you like to write readable code? Code that you can understand a year later? Code that your co-workers can understand?
If so, you need to use good abstractions in your source code. What makes an abstraction good? How do you arrive at good abstractions?
Most programmers try to ‘invent’ abstractions from scratch. This is an elusive goal. It requires a level of foresight rarely available. What if, instead, you could use existing, universal abstractions?
For decades, programmers have dreamt of being able to assemble software from building blocks, like Lego bricks. In order to do this, such building blocks must be composable, like Lego bricks. What makes an abstraction composable? It turns out that category theory can teach us about composability. Furthermore, it turns out that some of the most important structural design patterns in the Gang of Four book are special cases of categories.
Category theory is a branch of mathematics, and so includes objective laws. You can use those laws to determine whether an abstraction is composable – even in object-oriented programming!
Target audience and goal of the workshop
In this workshop, you’ll learn some objective criteria to determine whether a design is composable. No special background in mathematics is required.
The workshop will include a combination of lecture and exercises, including hands-on programming exercises. You’ll need to bring your own programming environment capable of compiling and running C# code. The fanciest C# features you’ll use is generics, so programmers with only passing familiarity with C# may be able to participate as well.
This workshop is for object-oriented programmers curious about category theory and functional programming. You’ll see F# and Haskell code examples during the workshop, but you don’t have to know these language; you’ll learn what you need along the way.
Successful participation in the workshop should enable you to use universal abstractions in your source code. As always, no silver bullet is implied. You will learn about universal abstractions, but it will not magically make all your code instantly perfect.
In this one-day workshop, we’ll take a demo micro-service application running on ASP.NET Core and get it working in Docker containers, from our local machines to a full Swarm running in the Cloud.
using Docker as a development tool for running services and testing our own containers engineering ASP.NET Core applications for distributed, replicated environments the pros and cons of different inter-service communication options (e.g. HTTP, GRPC, etc) different Docker Orchestration platforms, including Docker Swarm Mode and Kubernetes continuous integration and deployment deploying and maintaining complete multi-service application stacks with simple commands common problems and pitfalls and how to avoid them. No previous knowledge of Docker is required, although any experience with ASP.NET will be helpful.
DevOps is the implementation of continuous delivery and agile concepts across the organization, focusing on pipelines as the main building blocks for delivery value internally and to the customer. But getting to that state is complicated because it requires several facets of work: People, process and tools. In large organizations, we have the added complexity of: • Multiple dependencies and sub systems • Multiple teams, groups, business units with competing interests • Varying degrees of agility, culture, tools, technologies and processes • Security, compliance and policy gates In this workshop, we will discuss main patterns and anti-patterns for adopting and implementing DevOps pipelines throughout the organization, that scale.
Additionally Robot Kit Hardware Cost is 60 EUR.