#performance metrics design pattern spring boot | Explore Tumblr posts and blogs

shalcool15 · 1 year ago

Text

Building Applications with Spring boot in Java

Spring Boot, a powerful extension of the Spring framework, is designed to simplify the process of developing new Spring applications. It enables rapid and accessible development by providing a convention-over-configuration approach, making it a preferred choice for many developers. This essay delves into the versatility of Spring Boot, exploring the various types of applications it is commonly used for, highlighting its features, benefits, and practical applications across industries.

Origins and Philosophy

Spring Boot was created to address the complexity often associated with Spring applications. By offering a set of auto-configuration, management, and production-ready features out of the box, it reduces the need for extensive boilerplate configuration. This framework adheres to the "opinionated defaults" principle, automatically configuring Spring applications based on the dependencies present on the classpath. This approach significantly accelerates development time and lowers the entry barrier for businesses looking to hire Java developers.

Web Applications

Spring Boot is widely recognized for its efficacy in building web applications. With embedded servers like Tomcat, Jetty, or Undertow, developers can easily create standalone, production-grade web applications that are ready to run. The framework's auto-configuration capabilities, along with Spring MVC, provide a robust foundation for building RESTful web services and dynamic websites. Spring Boot also supports various templates such as Thymeleaf, making the development of MVC applications more straightforward.

Microservices

In the realm of microservices architecture, Spring Boot stands out for its ability to develop lightweight, independently deployable services. Its compatibility with Spring Cloud offers developers an array of tools for quickly building some of the common patterns in distributed systems (e.g., configuration management, service discovery, circuit breakers). This makes Spring Boot an ideal choice for organizations transitioning to a microservices architecture, as it promotes scalability, resilience, and modularity. Microservices is one important reason why businesses look to migrate to Java 11 and beyond.

Cloud-Native Applications

Spring Boot's design aligns well with cloud-native development principles, facilitating the creation of applications that are resilient, manageable, and observable. By leveraging Spring Boot's actuator module, developers gain insights into application health, metrics, and audit events, which are crucial for Java development services companies maintaining and monitoring applications deployed in cloud environments. Furthermore, Spring Boot's seamless integration with containerization tools like Docker and Kubernetes streamlines the deployment process in cloud environments.

Enterprise Applications

Spring Boot is adept at catering to the complex requirements of enterprise applications. Its seamless integration with Spring Security, Spring Data, and Spring Batch, among others, allows for the development of secure, transactional, and data-intensive applications. Whether it's managing security protocols, handling transactions across multiple databases, or processing large batches of data, Spring Boot provides the necessary infrastructure to develop and maintain robust enterprise applications.

IoT and Big Data Applications

The Internet of Things (IoT) and big data are rapidly growing fields where Spring Boot is finding its footing. By facilitating the development of lightweight, high-performance applications, Spring Boot can serve as the backbone for IoT devices' data collection and processing layers. Additionally, its compatibility with big data processing tools like Apache Kafka and Spring Data makes it suitable for building applications that require real-time data processing and analytics.

Summary

Spring Boot's versatility extends across various domains, making it a valuable tool for developing a wide range of applications—from simple CRUD applications to complex, distributed systems. Its convention-over-configuration philosophy, combined with the Spring ecosystem's power, enables developers to build resilient, scalable, and maintainable applications efficiently.

In essence, Spring Boot is not just a tool for one specific type of application; it is a comprehensive framework designed to meet the modern developer's needs. Its ability to adapt to various application requirements, coupled with the continuous support and advancements from the community, ensures that Spring Boot will remain a crucial player in the software development landscape for years to come. Whether for web applications, microservices, cloud-native applications, enterprise-level systems, or innovative fields like IoT and big data, Spring Boot offers the flexibility, efficiency, and reliability that modern projects demand. The alternative Spring cloud also offers variety of advantage for developers building microservices in java with spring boot and spring cloud.

#software development #web development #mobile app development #java full stack developer #java application development #javaprogramming #microservices

0 notes

codeonedigest · 2 years ago

Text

Performance Metrics Design Pattern Tutorial with Examples for Software Programmers

Full Video Link https://youtu.be/ciERWgfx7Tk Hello friends, new #video on #performancemetrics #designpattern for #microservices #tutorial for #programmers with #examples is published on #codeonedigest #youtube channel. Learn #performance #metr

In this video we will learn about Performance Metrics design pattern for microservices. This is the 2nd design principle in Observability design patterns category for microservices. Microservice architecture structures an application as a set of loosely coupled microservices and each service can be developed independently in agile manner to enable continuous delivery. But how to analyse and…

View On WordPress

0 notes

xceltecseo · 3 years ago

Text

What Are the Most Popular Java Frameworks in 2022 for Enterprise App development?

The popularity of Java as the most dependable programming language seems to be escalating annually. Despite the emergence of rival platforms that are similar to Java, its popularity has mostly remained unopposed. Programmers typically like Java, especially when creating enterprise-level applications. However, it's not just Java enterprise apps. A range of software solutions, including internet and mobile apps, can be made using the framework. Java increases productivity by providing a strong operating framework. For the creation of enterprise app development in 2022 and beyond, XcelTec has introduced the most well-liked Java frameworks.

Most Popular Java Frameworks for Enterprise App Development in 2022

Spring Boot:

An open source Java web framework called Spring Boot is based on microservices. The Spring Boot framework offers a completely customizable, production-ready environment thanks to its prebuilt code. The microservice architecture, which contains embedded application servers, allows developers to design fully contained applications.

Spring MVC:

It is a Java framework used to create web applications. It makes use of the Model-View-Controller design pattern. Additionally, it supports all of the essential Spring Framework features, such as Dependency Injection and Inversion of Control. Spring MVC provides a respectable way to use MVC in the Spring Framework with the help of DispatcherServlet. In this case, a class called DispatcherServlet is used to receive incoming requests and direct them to the proper resources, such as Controllers, Models, and Views.

Hibernate:

A Java framework called Hibernate looks after the implementations and includes an abstraction layer. The implementations involve creating a query for CRUD operations, connecting to databases, and other tasks.

Software called a framework abstracts away several different technologies, including servlets and JDBC.In order to enable the use of data for a longer period of time, Hibernate develops persistence logic that saves and processes data. It has an edge over other frameworks because it is a simple ORM tool that is also open-source.

Hadoop:

For storing, processing, and analysing massive amounts of data, Hadoop is an Apache open-source framework. A Java-based, non-OLAP database is called Hadoop (online analytical processing). It also enables batch and offline processing. It is used by numerous websites, including Facebook, Yahoo, Google, Twitter, LinkedIn, and many others.

Kafka:

A distributed streaming technique is used by the software platform Apache Kafka to process data. Data can be transferred among apps, servers, and processors using this publish-subscribe messaging mechanism. Apache Kafka was initially created by LinkedIn and later donated to the Apache Software Foundation. Confluent is now working on it as a part of the Apache Software Foundation. Apache Kafka has solved the issue of data transfer being delayed between a sender and a receiver.

Spark:

The Ruby Sinatra framework served as the model for the Spark rapid development web framework. It is less verbose than usual Java framework applications because it is based on the Java 8 Lambda Expression paradigm.

Swagger:

The industry standard for API documentation is called Swagger. Swagger is useful while implementing APIs on Azure. Programming language Swagger is mostly used to describe APIs.

Express.JS:

Express.JS is a speedy, aggressive, necessary, and modest Node.js web framework. You could think of express as a Node.js layer that helps with server and route management. It includes a wide variety of tools for building mobile and online applications.

Dropwizard:

A Java framework called Dropwizard makes it simple to quickly develop high-performance RESTful web services. To create a compact package, it incorporates a number of well-known libraries. The main libraries it uses are Jetty, Jersey, Jackson, JUnit, and Guava. It also uses a library of metrics that it has created. High performance, dependability, and stability can all be achieved with RESTful web apps.

Conclusion:

If you are wanting to create an application, XcelTec can assist you with java development services that can be genuinely helpful for enterprise app development. Hopefully, you now have a better understanding of how important java can be for your organisation.

Visit to explore more on What Are the Most Popular Java Frameworks in 2022 for Enterprise App development?

Get in touch with us for more!

Email us at:- [email protected]

#java frameworks #enterprise app development #most popular java frameworks #java development company #hire java developers

0 notes

siva3155 · 6 years ago

Text

300+ TOP Spring Boot Interview Questions and Answers

Spring Boot Interview Questions for freshers experienced :-

1. What is Spring Boot? Earlier, while working with huge enterprise computing softwares, developers had to focus both on the coding part and on the mass amount of configurations. Consequently, this resulted in a problem where developers could not dedicate the needful amount of time to coding. Therefore, Spring Boot came into picture. Spring Boot is an architecture built on top of the conventional spring framework. It allows developers to create deployment ready applications with configurations and linked jar files. Below are the 4 key Spring Boot components: Spring Boot AutoConfigurator Spring Boot Starters Spring Boot Actuator Spring Boot CLI 2. Why do we need Spring Boot? This is one of the most frequently asked Spring Boot Interview Questions and Answers that you must be aware about. While Spring framework provides developers with an ideal environment to build large applications, it often involves a number of jar files, configurations, server establishment, dispatcher servlet, component scan, view resolver, and much more, which results as a hindrance to the development. Spring Boot is designed to relieve developers from this rattling problem. It provides with features such as starter projects where developers can find pre built projects for further development, auto configurations, etc., so that the application developers can focus on the conventions. 3. How is Spring Boot architecture? Is it the same as Spring MVC? Although Spring Boot is built as an architecture to Spring framework, it is not the same as Spring MVC, nor is a substitution to the latter one. In simple words, Spring Boot is a mediator that helps a developer to connect, configure, and develop more easily and efficiently with the Spring framework. Some of the auto configuration files provided by Spring Boot are database config, security config, and security config, which saves essential development time. Moreover, there are features such as Spring Boot Starters, which cannot to found in Spring MVC. 4. What is Spring Boot Starters? Moving ahead with the Spring Boot Interview Questions and Answers, it is important to know about Spring Boot Starters, which is one of the 4 major components of Spring Boot. To build a single application, there are a lot of dependencies in the Spring framework. Spring Boot Starter POMs are designed to reduce these dependencies into a single one. Therefore, instead of going through a lot of data to find a sample code and copy the dependencies, Spring Boot Starters provides developers with a ready to use all in one set of dependencies. Some of the Spring Boot Starters are Web Starter, Test Starter, Mail Starter, Data JPA Starter. Jar dependencies can be added to Maven’s pom.xml or Gradle’s build.gradle file. org.springframework.boot spring-boot-starter-parent 1.4.0.RELEASE 5. What is Spring Boot AutoConfiguration, and why do we need AutoConfiguration? Spring Boot autoconfigurator is one of the 4 key components of Spring Boot. It uses defined jar dependencies to automatically add configurations to your Spring MVC application. @Configurationpublic class MySQLAutoconfiguration { } Further, a class is registered under org.springframework.boot.autoconfigure. EnableAutoConfiguration key in the location resources/META-INF/spring.factories: This class acts as an auto configuration candidate. org.springframework.boot.autoconfigure. EnableAutoConfiguration=\ com.training.springboot.autoconfiguration. MySQLAutoconfiguration 6. What is Spring Boot CLI? CLI stands for the Command Line Interface. Spring Boot CLI, as the name suggests, is used to begin quickly with the development using the Spring framework. Often, developers have to spend a lot of time after writing boilerplate code, which is nothing but a few lines of code that has to be included time by time with a little bit of modification. Groovy scripts provided by Spring Boot CLI makers sure that app developers can spend time after conventional coding parts and business logic. Such a set up makes sure Spring application is developed and deployed more quickly and efficiently. 7. What is Spring Boot Actuator? Once the application is deployed, Spring Boot Actuator allows you to bring production-ready features to it. Features for monitoring application, traffic patterns, metrics, health, env, and other operation-related insights are provided by the Spring Boot Actuator. It makes use of HTTP endpoints to enable the interaction, which can be extended further in multiple ways same as other components of Spring Boot. org.springframework.boot spring-boot-starter-actuator Note: Regardless of the Spring Boot version, the above setup remains true just as specified in the BOM(Spring Boot Bill of Materials). 8. How to create a Spring Boot Project? While facing Spring Boot Interview Questions and Answers, a candidate might be asked to create a simple Spring Boot project, which can be easily accomplished following below guideline or one may create a Spring Boot project following the guidelines provided on https://start.spring.io/ Spring Boot Project

spring boot project Folder Structure:

folder structure The main method is the heart of the Spring boot application to run the application. @SpringBootApplication: The @SpringBootApplication annotation is the same as using @EnableAutoConfiguration, @Configuration, and @ComponentScan with default attributes. @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME) @Documented @Inherited @SpringBootConfiguration @EnableAutoConfiguration @ComponentScan(excludeFilters = { @Filter(type = FilterType.CUSTOM, classes = TypeExcludeFilter.class), @Filter(type = FilterType.CUSTOM, classes = AutoConfigurationExcludeFilter.class) }) public @interface SpringBootApplication { } 9. What is @Configuration and why is it needed? @Configuration is a Spring annotation that is used to indicate @Bean method declaration by a class. It can be processed by Spring container in order to create service requests and bean definitions during runtime. @Configuration is: Required, only when the annotated class is defined in the @ComponentScan annotation but is not passed explicitly. Not Required, if the annotated class is passed in the source parameters while calling SpringApplication.run(). 10. What is @RestController annotation? @RestController is a specialized controller that includes @ResponseBody and @controller annotations. @RestController is mainly used to simplify the controller implementation. @RestController public class HelloController { @RequestMapping("/hello") public String greeting() { return"HelloWorld"; } }

Spring Boot Interview Questions 11. What is @RequestMapping annotation? It is not unusual to be asked regarding various annotations while facing Spring Boot Interview Questions and Answers. However, do not hesitate and give your answer in simple terms using technical information such as below. @RequestMapping is used to map class-level and method-level annotations. It maps class-level annotations with the controller in the requested pattern or path. Further, @RequestMapping specifies mappings to handler methods with method-level annotations. 12. What is @RequestBody annotation? @RequestBody annotation is used to bind a method parameter to incoming HTTP requests with the mentioned URL in @RequestMapping annotation. Here, HTTP message convertors are used to map HttpRequest body to a domain object, which consequently helps to automatically deserialize the body to a Java object based on header present in the request. 13. What is @ResponseBody annotation? The task of @ResponseBody annotations is to inform the controller that the returned object has been serialized into Json, the returned value will be bound to HttpResponse body. Here, Spring HTTP message converters serialize the return value to the type specified in HTTP header. 14. What is @ResponseEntity annotation? @ResponseEntity, as the name suggests, is an annotation that represents the HTTP response entity. @ResponseEntity contains constructors that allow you to specify status code, body, header, and other information. 15. What is @pathVariable? @PathVariable annotation is used to directly extract information from the URI. 16. What is MediaType? MediaType is used to specify the type of data that is to be produced or consumed by the controller. This narrows down and aids with mapping. 17. What is REST API? Restful API is one of the favorite Spring Boot Interview Questions and Answers of recruiters to interrogate a fresher candidate. REST API or RESTful API is used to transfer http requests such as Get, Post, Put, and Delete. REST or Representational Transfer is a technology that imitates communication style used for web services. 18. What are the types of HTTP methods and Corresponding RestTemplate methods? GET: Read operations Use: To retrieve the list of customers and use sorting, pagination, and filtering to navigate big lists. Status codes: 200 – (OK) valid request, 404 – (Not Found) Invalid request. POST: Location header with link to /customers/{id} containing new ID Use: To create the newrecord with new id. Status codes: 201 (Created), 404 (Not Found), 409 (Conflict) if resource already exists. PUT: To update/replace every resource in the entire collection. Use: To update/replace data Status codes: 405 (Method Not Allowed), 200 (OK), or 204 (No Content), 404 (Not Found), in case of ID invalid or not found. PATCH: unless you want to modify the collection itself. Use: To update/modify data Status codes: 405 (Method Not Allowed), 200 (OK), or 204 (No Content), 404 (Not Found), in case of ID invalid or not found. DELETE: To completely delete the collection – often not desirable Use: To perform deletion Status codes: 405 (Method Not Allowed), 200 (OK), or 204 (No Content), 404 (Not Found), in case of ID invalid or not found. 19. Difference between POST and PUT methods? Basically, Put is used to replace all the target resources with the selected/requested payload. On the other hand, Post method is used to submit or send data to the specific server or resource such as file upload, information, or changing the current status. An explicitly created object suggest use of the Put method while server-specified name shows the use of Post method. Put allows you to Put objects more than a single time and also allows creation or updation of resources using the exact object or URL. On the other hand, Post allows multiple requests at the same time to make changes to an object or URL. 20. What is @Autowired annotation and its usage? Same as the @Required annotation, @Autowired annotation can be used to bind or autowire bean with the setter method. In other words, one can implicitly define object dependency. It provides developers with control regarding autowiring. 21. How many ways the autowired can mode? No: It’s the default option. Defining not to autowire, which is set using ref attribute. byName: This makes use of property name for autowiring. If bean name matches other bean property name, autowiring is done. byType: Same way as the byName mode, if the bean data type is shown to be compatible with other bean property, autowiring is done. Constructor: byType mode defined in constructor. Autodetect: Finds the default constructor for autowiring. If not found, byType autowiring is performed. 22. What are the limitations of autowiring mode? If constructor contains explicit dependencies, they will override autowiring instructions. Possibilities of Overriding: Dependencies can be easily defined using constructor-arg or property tags to override the autowiring. String, integer, and similar data type properties have to be defined manually and cannot be autowired. 23. What is spring-boot-starter-data-jpa? Spring Boot provides spring-boot-starter-data-jpa, which is one of the Spring Boot Starters, to easily connect relational database with Spring MVC applications. org.springframework.boot spring-boot-starter-data-jpa 24. How does JPA Work? JPA stands for Java Persistence API, which is used as an API that allows the developers to work with objects. When you deal with a relational database, you have to make use of SQL statements in order to retrieve information for certain queries. JPA eliminates the need of using SQL statements and allows the developers to deal with objects without SQL statement requisite. Developers can perform actions such as accessing, modifying, managing, and persisting information. A JPA persistence provider can create a database schema by following the information provided in metadata. Here, JPA metadata has to be defined in the Java class. Metadata can also be defined using XML. JPA can handle both static and dynamic object-based queries. 25. What is the difference between JPA and Hibernate? While JPA and Hibernate both are completely different entities, they are interconnected in certain ways. JPA is an API that provides developers with specifications and guidelines for implementation. However, it is not an implementation and will require a tool that can implement the specifications. Consequently, Hibernate comes into picture, which is nothing but a tool that follows the guideline as well as compulsory and optional specifications defined by JPA and makes it functional. Using Hibernate for JPA implementation also allows you to switch over other implementation tools easily, which is not possible if used Hibernate alone. 26. What is spring-boot-starter-test? Spring-boot-starter-test is the dedicated testing module of the Spring Boot. It brings the Starter Test Modules and a certain number of libraries to test your application. Following is the list of libraries in the Spring-boot-starter-test module: Hamcrest JsonPath JUnit AssertJ Mockito Spring Test & Spring Boot Test JSONassert org.springframework.boot spring-boot-starter-test test 27. How to test the Controller class in Spring Boot? To test the controller class in Spring Boot, developers have the following 2 alternatives: To use the mock environment or To use an embedded Servlet container. 28. What is @RunWith(SpringJUnit4ClassRunner.class)? @RunWith is an annotation used to define if a class should run along a specific runner class. SpringJUnit4ClassRunner.class is used as Spring Boot makes use of the Spring test. A developer can choose from multiple of runners based on the test. 29. What is @ContextConfiguration annotation? In order to configure ApplicationContext for tests such as integration, @ContextConfiguration annotation is used. It shows ApplicationContext resource and classes utilized to load it. @ContextConfiguration calls ClassPathContextConfiguration, which helps to identify the Java classes and ContextLoader to run on JVM. Same way, AnnotationConfigContextLoader.class is a ContextLoader used to determine the classes to load. If you are asked to provide an example for @ContextConfiguration during Spring Boot Interview Questions and Answers, use the below code. A simple example for the @ContextConfiguration annotation: @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(classes = Sample.class, loader = AnnotationConfigContextLoader.class) public class JUnitSpringExample {} Class file: @Configuration public class Sample { @Bean public SampleService getSampleService() { return new SampleServiceImpl(); }} 30. What is Swagger2? Swagger is used to describe the structure of APIs. Swagger 2 is an open source service provided in Spring Boot that makes it easier for the machines to identify the structure of APIs such as RESTful Web services. io.springfox springfox-swagger2 2.9.2 31. How to integrate the Swagger2? Below is a sample for integration of Swagger2 with docket: @Configuration @EnableSwagger2 public class SwaggerConfig { @Bean public Docket api() { return new Docket(DocumentationType.SWAGGER_2) .select() .apis(RequestHandlerSelectors.any()) .paths(PathSelectors.any()) .build(); } } @EnableSwagger2 annotation is used to enable Swagger 2. Once Docket bean is specified, select method returns an ApiSelectorBuilder instance. This instance is used to determine how to control the exposed endpoints. RequestHandlerSelectors and PathSelectors are used to configure predicates for of RequestHandler selection. Lastly, any() method will facilitate the documentation using Swagger. Above configuration can be used to integrate Swagger2 with a Spring Boot Application. Spring Boot Questions and Answers Pdf Download Read the full article

0 notes

nox-lathiaen · 7 years ago

Text

Java Solution Architect

Role: Java Solution Architect Location: Topeka, KS Duration: Contract Job Description: • Translate models such as Business Process Models, Process Mapping Models and Task Mapping models among others, from Business Architecture into actionable Solution Architectures that can be further elaborated into detailed specifications such as OpenAPI (Swagger), Technical Architecture Design Documents, Feature Stories and User Stories, Non-Functional Requirements (NFRs), Test/Acceptance Criteria, etc. as needed. • Leverage ARIS to express the Solution Architecture from Conceptual, Logical, and Physical viewpoints. • Identify existing external behaviors of the Business, Application, and Technology/Infrastructure layers and describe in Archimate viewpoint models how these behaviors will interact structurally in a Target State to realize the designated Business Processes across all layers to be implemented within a Micro Services Solution Architecture. • Elicit detailed business rules from a code-decomposition process that will inform system behavior and performance of the desired Target State • Effectively communicate with Business Leadership, Product Owners, Product Managers, Architecture Teams, and Feature Team Developers to drive out a Roadmap of deliverables to transition from the Current State to the desired Target State within a Scaled Agile Framework process. • Ensure the Feature Team developers are equipped to perform full DevOps capabilities within a Continuous Deployment environment, including: Agile Code Reviews, Code Coverage and Quality metrics, Automated Unit and Functional Testing, Automated User Acceptance and Approval Processes, etc. • Contribute quality, secure, performant, and tested code that may address complex system aspects or other areas as needed to meet the Sprint objectives. • Describe common patterns at many levels within the implementation space and identify when to apply these patterns: o Software Refactoring Patterns  ‘Extract Method’  ‘Inline Method’  ‘Replace Constructor with Factory Method’  ‘Replace Conditional with Polymorphism’  ‘Tease Apart Inheritance’ o Software Design Patterns  Prototype  Singleton  Factory Method  Strategy  Iterator  Proxy  Decorator  Façade o Enterprise Application Architecture  Model View Controller  Optimistic Offline Lock  Separated Interface  Registry  Repository o Enterprise Integration Patterns  Event Message  Dynamic Router  Command Message  Service Activator o Micro Service Patterns  Backend for Frontend  Circuit Breaker  Anti-corruption Layer  CQRS  Event Sourcing  External Configuration Store • Describe principles of the 12-factor App and how to achieve them Furthermore the following technologies must be understood and leveraged as part of the desired Target State Micro Service Solution Architecture: • Apache Kafka • Spring Framework • Spring Boot • Gradle • Jenkins • GitHub • Open Shift • Docker • Kubernetes • ReactJS and/or AngularJS • Cassandra • Distributed Cache/Data Grid • DB2 JSON / MongoDB • DB2 SQL • Redis Reference : Java Solution Architect jobs Source: http://jobrealtime.com/jobs/technology/java-solution-architect_i2554

0 notes

faizrashis1995 · 5 years ago

Text

What’s After the MEAN Stack?

Introduction

We reach for software stacks to simplify the endless sea of choices. The MEAN stack is one such simplification that worked very well in its time. Though the MEAN stack was great for the last generation, we need more; in particular, more scalability. The components of the MEAN stack haven’t aged well, and our appetites for cloud-native infrastructure require a more mature approach. We need an updated, cloud-native stack that can boundlessly scale as much as our users expect to deliver superior experiences.

Stacks

When we look at software, we can easily get overwhelmed by the complexity of architectures or the variety of choices. Should I base my system on Python? Or is Go a better choice? Should I use the same tools as last time? Or should I experiment with the latest hipster toolchain? These questions and more stymie both seasoned and newbie developers and architects.

Some patterns emerged early on that help developers quickly provision a web property to get started with known-good tools. One way to do this is to gather technologies that work well together in “stacks.” A “stack” is not a prescriptive validation metric, but rather a guideline for choosing and integrating components of a web property. The stack often identifies the OS, the database, the web server, and the server-side programming language.

In the earliest days, the famous stacks were the “LAMP-stack” and the “Microsoft-stack”. The LAMP stack represents Linux, Apache, MySQL, and PHP or Python. LAMP is an acronym of these product names. All the components of the LAMP stack are open source (though some of the technologies have commercial versions), so one can use them completely for free. The only direct cost to the developer is the time to build the experiment.

The “Microsoft stack” includes Windows Server, SQL Server, IIS (Internet Information Services), and ASP (90s) or ASP.NET (2000s+). All these products are tested and sold together.

Stacks such as these help us get started quickly. They liberate us from decision fatigue, so we can focus instead on the dreams of our start-up, or the business problems before us, or the delivery needs of internal and external stakeholders. We choose a stack, such as LAMP or the Microsoft stack, to save time.

In each of these two example legacy stacks, we’re producing web properties. So no matter what programming language we choose, the end result of a browser’s web request is HTML, JavaScript, and CSS delivered to the browser. HTML provides the content, CSS makes it pretty, and in the early days, JavaScript was the quick form-validation experience. On the server, we use the programming language to combine HTML templates with business data to produce rendered HTML delivered to the browser.

We can think of this much like mail merge: take a Word document with replaceable fields like first and last name, add an excel file with columns for each field, and the engine produces a file for each row in the sheet.

As browsers evolved and JavaScript engines were tuned, JavaScript became powerful enough to make real-time, thick-client interfaces in the browser. Early examples of this kind of web application are Facebook and Google Maps.

These immersive experiences don’t require navigating to a fresh page on every button click. Instead, we could dynamically update the app as other users created content, or when the user clicks buttons in the browser. With these new capabilities, a new stack was born: the MEAN stack.

What is the MEAN Stack?

The MEAN stack was the first stack to acknowledge the browser-based thick client. Applications built on the MEAN stack primarily have user experience elements built in JavaScript and running continuously in the browser. We can navigate the experiences by opening and closing items, or by swiping or drilling into things. The old full-page refresh is gone.

The MEAN stack includes MongoDB, Express.js, Angular.js, and Node.js. MEAN is the acronym of these products. The back-end application uses MongoDB to store its data as binary-encoded JavaScript Object Notation (JSON) documents. Node.js is the JavaScript runtime environment, allowing you to do backend, as well as frontend, programming in JavaScript. Express.js is the back-end web application framework running on top of Node.js. And Angular.js is the front-end web application framework, running your JavaScript code in the user’s browser. This allows your application UI to be fully dynamic.

Unlike previous stacks, both the programming language and operating system aren’t specified, and for the first time, both the server framework and browser-based client framework are specified.

In the MEAN stack, MongoDB is the data store. MongoDB is a NoSQL database, making a stark departure from the SQL-based systems in previous stacks. With a document database, there are no joins, no schema, no ACID compliance, and no transactions. What document databases offer is the ability to store data as JSON, which easily serializes from the business objects already used in the application. We no longer have to dissect the JSON objects into third normal form to persist the data, nor collect and rehydrate the objects from disparate tables to reproduce the view.

The MEAN stack webserver is Node.js, a thin wrapper around Chrome’s V8 JavaScript engine that adds TCP sockets and file I/O. Unlike previous generations’ web servers, Node.js was designed in the age of multi-core processors and millions of requests. As a result, Node.js is asynchronous to a fault, easily handling intense, I/O-bound workloads. The programming API is a simple wrapper around a TCP socket.

In the MEAN stack, JavaScript is the name of the game. Express.js is the server-side framework offering an MVC-like experience in JavaScript. Angular (now known as Angular.js or Angular 1) allows for simple data binding to HTML snippets. With JavaScript both on the server and on the client, there is less context switching when building features. Though the specific features of Express.js’s and Angular.js’s frameworks are quite different, one can be productive in each with little cross-training, and there are some ways to share code between the systems.

The MEAN stack rallied a web generation of start-ups and hobbyists. Since all the products are free and open-source, one can get started for only the cost of one’s time. Since everything is based in JavaScript, there are fewer concepts to learn before one is productive. When the MEAN stack was introduced, these thick-client browser apps were fresh and new, and the back-end system was fast enough, for new applications, that database durability and database performance seemed less of a concern.

The Fall of the MEAN Stack

The MEAN stack was good for its time, but a lot has happened since. Here’s an overly brief history of the fall of the MEAN stack, one component at a time.

Mongo got a real bad rap for data durability. In one Mongo meme, it was suggested that Mongo might implement the PLEASE keyword to improve the likelihood that data would be persisted correctly and durably. (A quick squint, and you can imagine the XKCD comic about “sudo make me a sandwich.”) Mongo also lacks native SQL support, making data retrieval slower and less efficient.

Express is aging, but is still the defacto standard for Node web apps and apis. Much of the modern frameworks — both MVC-based and Sinatra-inspired — still build on top of Express. Express could do well to move from callbacks to promises, and better handle async and await, but sadly, Express 5 alpha hasn’t moved in more than a year.

Angular.js (1.x) was rewritten from scratch as Angular (2+). Arguably, the two products are so dissimilar that they should have been named differently. In the confusion as the Angular reboot was taking shape, there was a very unfortunate presentation at an Angular conference.

The talk was meant to be funny, but it was not taken that way. It showed headstones for many of the core Angular.js concepts, and sought to highlight how the presenters were designing a much easier system in the new Angular.

Sadly, this message landed really wrong. Much like the community backlash to Visual Basic’s plans they termed Visual Fred, the community was outraged. The core tenets they trusted every day for building highly interactive and profitable apps were getting thrown away, and the new system wouldn’t be ready for a long time. Much of the community moved on to React, and now Angular is struggling to stay relevant. Arguably, Angular’s failure here was the biggest factor in React’s success — much more so than any React initiative or feature.

Nowadays many languages’ frameworks have caught up to the lean, multi-core experience pioneered in Node and Express. ASP.NET Core brings a similarly light-weight experience, and was built on top of libuv, the OS-agnostic socket framework, the same way Node was. Flask has brought light-weight web apps to Python. Ruby on Rails is one way to get started quickly. Spring Boot brought similar microservices concepts to Java. These back-end frameworks aren’t JavaScript, so there is more context switching, but their performance is no longer a barrier, and strongly-typed languages are becoming more in vogue.

As a further deterioration of the MEAN stack, there are now frameworks named “mean,” including mean.io and meanjs.org and others. These products seek to capitalize on the popularity of the “mean” term. Sometimes it offers more options on the original MEAN products, sometimes scaffolding around getting started faster, sometimes merely looking to cash in on the SEO value of the term.

With MEAN losing its edge, many other stacks and methodologies have emerged.

The JAM Stack

The JAM stack is the next evolution of the MEAN stack. The JAM stack includes JavaScript, APIs, and Markup. In this stack, the back-end isn’t specified – neither the webserver, the back-end language, or the database.

In the JAM stack we use JavaScript to build a thick client in the browser, it calls APIs, and mashes the data with Markup — likely the same HTML templates we would build in the MEAN stack. The JavaScript frameworks have evolved as well. The new top contenders are React, Vue.js, and Angular, with additional players from Svelte, Auralia, Ember, Meteor, and many others.

The frameworks have mostly standardized on common concepts like virtual dom, 1-way data binding, and web components. Each framework then combines these concepts with the opinions and styles of the author.

The JAM stack focuses exclusively on the thick-client browser environment, merely giving a nod to the APIs, as if magic happens behind there. This has given rise to backend-as-a-service products like Firebase, and API innovations beyond REST including gRPC and GraphQL. But, just as legacy stacks ignored the browser thick-client, the JAM stack marginalizes the backend, to our detriment.

Maturing Application Architecture

As the web and the cloud have matured, as system architects, we have also matured in our thoughts of how to design web properties.

As technology has progressed, we’ve gotten much better at building highly scalable systems. Microservices offer a much different application model where simple pieces are arranged into a mesh. Containers offer ephemeral hardware that’s easy to spin up and replace, leading to utility computing.

As consumers and business users of systems, we almost take for granted that a system will be always on and infinitely scalable. We don’t even consider the complexity of geo-replication of data or latency of trans-continental communication. If we need to wait more than a second or two, we move onto the next product or the next task.

With these maturing tastes, we now take for granted that an application can handle near infinite load without degradation to users, and that features can be upgraded and replaced without downtime. Imagine the absurdity if Google Maps went down every day at 10 pm so they could upgrade the system, or if Facebook went down if a million people or more posted at the same time.

We now take for granted that our applications can scale, and the naive LAMP and MEAN stacks are no longer relevant.

Characteristics of the Modern Stack

What does the modern stack look like? What are the elements of a modern system? I propose a modern system is cloud-native, utility-billed, infinite-scale, low-latency, user-relevant using machine learning, stores and processes disparate data types and sources, and delivers personalized results to each user. Let’s dig into these concepts.

A modern system allows boundless scale. As a business user, I can’t handle if my system gets slow when we add more users. If the site goes viral, it needs to continue serving requests, and if the site is seasonally slow, we need to turn down the spend to match revenue. Utility billing and cloud-native scale offers this opportunity. Mounds of hardware are available for us to scale into immediately upon request. If we design stateless, distributed systems, additional load doesn’t produce latency issues.

A modern system processes disparate data types and sources. Our systems produce logs of unstructured system behavior and failures. Events from sensors and user activity flood in as huge amounts of time-series events. Users produce transactions by placing orders or requesting services. And the product catalog or news feed is a library of documents that must be rendered completely and quickly. As users and stakeholders consume the system’s features, they don’t want or need to know how this data is stored or processed. They need only see that it’s available, searchable, and consumable.

A modern system produces relevant information. In the world of big data, and even bigger compute capacity, it’s our task to give users relevant information from all sources. Machine learning models can identify trends in data, suggesting related activities or purchases, delivering relevant, real-time results to users. Just as easily, these models can detect outlier activities that suggest fraud. As we gain trust in the insights gained from these real-time analytics, we can empower the machines to make decisions that deliver real business value to our organization.

MemSQL is the Modern Stack’s Database

Whether you choose to build your web properties in Java or C#, in Python or Go, in Ruby or JavaScript, you need a data store that can elastically and boundlessly scale with your application. One that solves the problems that Mongo ran into – that scales effortlessly, and that meets ACID guarantees for data durability.

We also need a database that supports the SQL standard for data retrieval. This brings two benefits: a SQL database “plays well with others,” supporting the vast number of tools out there that interface to SQL, as well as the vast number of developers and sophisticated end users who know SQL code. The decades of work that have gone into honing the efficiency of SQL implementations is also worth tapping into.

These requirements have called forth a new class of databases, which go by a variety of names; we will use the term NewSQL here. A NewSQL database is distributed, like Mongo, but meets ACID guarantees, providing durability, along with support for SQL. CockroachDB and Google Spanner are examples of NewSQL databases.

We believe that MemSQL brings the best SQL, distributed, and cloud-native story to the table. At the core of MemSQL is the distributed database. In the database’s control plane is a master node and other aggregator nodes responsible for splitting the query across leaf nodes, and combining the results into deterministic data sets. ACID-compliant transactions ensure each update is durably committed to the data partitions, and available for subsequent requests. In-memory skiplists speed up seeking and querying data, and completely avoid data locks.

MemSQL Helios delivers the same boundless scale engine as a managed service in the cloud. No longer do you need to provision additional hardware or carve out VMs. Merely drag a slider up or down to ensure the capacity you need is available.

MemSQL is able to ingest data from Kafka streams, from S3 buckets of data stored in JSON, CSV, and other formats, and deliver the data into place without interrupting real-time analytical queries. Native transforms allow shelling out into any process to transform or augment the data, such as calling into a Spark ML model.

MemSQL stores relational data, stores document data in JSON columns, provides time-series windowing functions, allows for super-fast in-memory rowstore tables snapshotted to disk and disk-based columnstore data, heavily cached in memory.

As we craft the modern app stack, include MemSQL as your durable, boundless cloud-native data store of choice.

Conclusion

Stacks have allowed us to simplify the sea of choices to a few packages known to work well together. The MEAN stack was one such toolchain that allowed developers to focus less on infrastructure choices and more on developing business value.

Sadly, the MEAN stack hasn’t aged well. We’ve moved on to the JAM stack, but this ignores the back-end completely.

As our tastes have matured, we assume more from our infrastructure. We need a cloud-native advocate that can boundlessly scale, as our users expect us to deliver superior experiences. Try MemSQL for free today, or contact us for a personalized demo.[Source]-https://www.memsql.com/blog/whats-after-the-mean-stack/

62 Hours Mean Stack Developer Training includes MongoDB, JavaScript, A62 angularJS Training, MongoDB, Node JS and live Project Development. Demo Mean Stack Training available.

0 notes