The September Issue of NFJS Magazine is out

In this issue I discuss the Cattle vs Pets analogy with a sprinkle of reality.  NFJS-September

Advertisements

VMworld 2016 and the Renaissance of the Application Platform Engineer

This year we will do a deep dive into:

How to Design and Tune Virtualized Trading Platforms – VIRT7507

Last year at VMworld 2015  and Spring-2015

Last year we highlighted the notion of Platform Engineering in the above sessions, and as briefly described here.

It is important to understand the elements of this rapidly moving phenomenon through our industry, a phenomenon of building platforms, not just business logic software but infrastructure as software. We humbly believe that the drive towards these platform solutions is due to the following fact: approximately half of new applications fail to meet their performance objectives, and almost all of these have 2.x more cloud capacity provisioned than what is actually needed. As developers we live with this fact every day, always chasing performance and feasible scalability, but never actually cementing it into a scientific equation where it is predictable, but rather it has always been trial based, and heavily prone to error. As a result we find ourselves delving with some interesting platforming patterns of this decade, and unfortunately we are lead to believe that such patterns as Microservices, 3rd platforms, cloud native, and 12factor are mainly a change in coding patterns, to the contrary – these patterns reveal a much more deep shift in the way developers view and consume infrastructure. In fact these patterns represent a major change in “deployment” approach, a change in how we deploy and structure code artifacts within applications runtimes, and how those application runtimes can leverage the underlying cloud capacity. These patterns are not code design patterns, but rather platform engineering patterns, with a drive to using APIs/Software to define application platform policies to manage scalability, availability and performance in a predictable manner. In the above session we  will briefly inspect platform patterns that we built over the last decade, and the ones we are building for the next decade. The main objective of the session will be to layout the definition of Platform Engineering as the software engineering science needed in order to understand how to precisely deploy application components onto application runtimes and how in-turn one should appropriately map the application runtimes onto the infrastructure that it needs. With this knowledge you should be able to more effectively decide when to scale-out (by how many instances), and when to scale-up both manually and dynamically as needed within your software defined platform.

My VMworld Sessions for 2015

VAPP4449 – How VMware Customers Build and Tune High Performance Application Platforms

The session will cover various platform architectures that are used in high end transactional systems at VMware customer sites, such as those found on trading platforms, and high volume order management systems. The deep dive will take a tour into structure of the platform, how to best scale it with virtualization, and how to deeply tune it for optimal performance. The session will share many best practices and actual examples used with customers that are running such high-end platforms. Specifically, Java GC and vSphere tuning techniques, and rationalization of large deployments having 1000s of VMs and JVMs will be discussed. Come to this session to learn about GC tuning and vSphere recipes that can give you the best configuration for latency sensitive applications high end performance platforms. We will show case in memory DBs with multiple terabyte clusters, but also looking at some monster JVM of 360GB Heap

Emad Benjamin – Principal Architect, VMware
Alessandro Quargnali-Linsley – Systems Engineer, Societe Generale
Program Location: Europe and US

VAPP4732 – Enterprise Application Architecture Influence on SDDC

Understanding enterprise application architecture influence on good SDDC design is at the core of what make a successful SDDC implementation. Often the divide between application developers and infrastructure architects is so great that the gap become very difficult to fill. On the development side developers look at the application layer concerns and tend to ignore infrastructure implementation paradigms, conversely infrastructure architects start at the bottom and never quite reach the design requirements of the application. In this session we demonstrate how this gap can be addressed.

Emad Benjamin – Principal Architect, VMware

Marco Caronna, Solutions Architect, VMware

Eamon Ryan, Sr. Solutions Architect
Program Location: US

CTO6659 – Ask the Experts – Cloud Native Applications

In the brave new world of IT there is a shift in customer expectations which which is driving a change in how applications are developed and operated (e.g. DevOps), how they’re architected (e.g. microservices and 12-factor apps), and how they”re deployed (e.g. Docker and containers). This is a shift in the balance of focus from Ops lead to a Dev lead world, where developers become a first class citizen of the datacenter. VMware calls these applications “cloud-native” as they’re designed for the mobile-cloud era. VMware launched Cloud-Native Apps at the beginning of the year to address the shift that is currently taking place how applications are developed today.

Emad Benjamin – Principal Architect, VMware
Joe Baguley – CTO EMEA, VMware
Robbie Jerrom – Senior Solutions Architect, VMware
Martijn Baecke – Solutions Consultant, VMware
Ed Hoppitt – CTO Ambassador, VMware
Program Location: Europe and US

What Should Happen on Day-2 of Containerization and Microservices Deployment Architecture?

Software component packaging is Day-1 concern for containers, however day-2 optimization of which container, how big the container, how many transactions the container will service in a scalable fashion, what other containers are related to the current container,  and their dynamic movement for better scalability and availability is the key aspect of taking a niche technology to the next level. These are all concerns of the next wave of commercialized products, no doubt developers want to quickly package something and deploy it to production, however, fundamentals of distributed computing and scalability don’t magically disappear.  The current container packaging wave is yet another developer behavior of trying to encapsulate the various software components, libraries and process details.  Packaging and containerization is great concept, after all containment concept is a natural progression of trying to abstract implementation detail, for example, we saw a similar progression with the concept of encapsulating many threads into a process, encapsulating may files into tar, many source codes into jars/wars etc.  The current wave of containerization is about encapsulating the software components and associated processes to the context of the application being deployed, as one deployment unit without the repeated overhead of an entire operating system.  The next wave will be about day-2 operations, and how to write DRS (VMware vCenter Distributed Resource Scheduler) like functionality for containers delivering the correct scale and meeting the response time SLA of an app, at the most cost efficient utilization of hardware.  In almost every corner of container discussions, microservices architecture is part and parcel of the discussion, and the service unit of a microservice is being positioned as the containerized deployment unit, this would lead to fragmented scale-out of the distributed platform that would negatively impact response times, I wrote a little about this here, a better answer would be to more appropriately containerize based on relationships between service usage as suggested in my earlier blog.  This type of containerization can be encoded into how the container is formed on day-1 if the developer intimately knows how the microservices graph is used, or the app is used, and perhaps it can be calculated by the runtime at incubation time, pilot/trial time, or even prod time.  Let’s say you deploy a deeply fragmented fashion microservices as touted by many early entrants, the underlying application/container/platform runtime engine can determine and give you recommendations of how to better deploy…more on this later.

Virtualizing and Tuning Java Workshop Videos

I would love to be able to come to your corner of the world and deliver these workshops, however this is obviously not practical.  The alternative is to take a look at videos of the workshops I have delivered at various events.

Spring2gx Session:

VMworld Sessions: