22 Apr 2024
is a revolutionary partner in auto transport logistics, offering customizable software solutions specially tailored to accommodate all your car hauling requirements. Our tools are impeccably designed to amplify your business's ability to streamline, automate, and organize the entire car hauling process, from start to finish. Through the development of various products, Ship.Cars has helped the automotive logistics industry to transition into the modern age. Our industry solutions, such as LoadMate and LoadMate Pro, cater to the various needs of dealerships, rental car companies, and other shippers. Meanwhile, innovations like our SmartHaul TMS and SmartHaul APP have become indispensable tools for our car haulers to book and manage their loads. CONTENDING WITH CHALLENGES As a product-centric organization, we utilize the microservice paradigm to deliver a diverse array of functionality via numerous distinct software products. Thus far, we've developed over 50 microservices. Each of these not only meets the requisite functional requirements but also adheres to rigorous technical specifications. These specifications ensure seamless provisioning of services, consistent performance under load, and easy identification and resolution of any arising issues. The construction of these services, over a large period of time, has relied on various frameworks, including Quarkus , Spring Boot and Django. Each framework exhibits its unique strengths and weaknesses extending from nuanced characteristics. However, with time, we've determined that Quarkus optimally fulfills a large portion of our requirements. This explains our current shift from Django to Quarkus for a significant portion of our development. As Ship.Cars deploys its microservices on Kubernetes within the Google Cloud platform, we continually seek efficient ways to scale our developmental prowess, while simultaneously saving cloud resource consumption. With cloud resource consumption costs always being a priority, we strive to find effective ways to optimize memory and processor use in the cloud. Common challenges often arise when deploying microservices in the cloud, including: 1. Lower cloud resource consumption: Multiple active microservices can consume a significant amount of memory and CPU, escalating costs rapidly. Hence, effective management of cloud resources is crucial. 2. Faster boot-up times: In a microservices architecture, it's important for services to stop, start, and scale swiftly. Slow boot-up times can have a severe impact on system performance and responsiveness. 3. Streamlined microservices development: Building and ensuring interoperability within microservices can be complex, requiring deft management and specialized tooling. 4. Resilience and fault tolerance: Microservices must be resilient and capable of quick recovery from unexpected failures. Implementing such fault tolerance mechanisms, however, can be challenging. 5. Service discovery: The ability to discover and communicate between services becomes critical as their number increases. Traditional hard-coded endpoints do not scale well in these scenarios. 6. Event-driven microservices: Implementing an event-driven architectural model in microservices enables distinct services to communicate asynchronously. Yet, orchestrating this can be difficult. 7. Reactive and imperative programming: The selection of an appropriate programming model for the cloud, especially one that supports scalability and system responsiveness, can be daunting. Quarkus could beautifully address these challenges as follows: 1. Lower cloud resource consumption: Known for their high memory usage, traditional Java applications can get expensive in a cloud environment where resources cost money. Quarkus significantly reduces the memory footprint of applications, leading to more efficient cloud resource management. 2. Faster boot-up times: Slow startup times are quite common with traditional Java applications, an issue that presents a particular problem in the cloud where applications need to scale up and down quickly. Quarkus drastically improves start-up performances, with applications often starting in sub-second times. 3. Streamlined microservices development: Quarkus has been designed to work with popular Java standards and technologies such as Eclipse MicroProfile, Jakarta EE, OpenTelemetry, Hibernate, etc., simplifying the development process and reducing the time and complexity involved. 4. Resilience and fault tolerance: Quarkus employs the MicroProfile Fault Tolerance specification to provide features like timeout, retry, bulkhead, circuit breaker, and fallback. These features render your microservices more resilient and fault-tolerant. 5. Service discovery: Quarkus supports Kubernetes service discovery natively, allowing services to discover and communicate with each other in a reliable manner. 6. Event-driven microservices: Quarkus supports event-driven architecture, enabling services to communicate through events, thereby reducing the complexity and coupling between the services. 7. Reactive and imperative programming: Quarkus gives developers the freedom to use reactive or imperative programming models or even combine both in the same application, creating a perfect solution for scalability and system responsiveness. TACKLING CLOUD RESOURCE CONSUMPTION For businesses like ours, one of our organizational goals is to reduce costs while not sacrificing platform's performance to ensure premium user experience. However, traditional JVM-based services often present challenges like substantial memory footprints, extended startup times, and high CPU usage. These problems not only impact technical aspects but also have financial implications, significantly affecting the overall cost of running and maintaining software solutions. Native images are standalone executables that include both the application code and the necessary runtime components. With the advent of GraalVM, a high-performance, polyglot virtual machine able to run applications written in different programming languages, the concept of native images has gained popularity. Native images offer several advantages, such as: * Faster startup time: As pre-compiled entities, native images can start incredibly quickly, often in milliseconds. This aspect is hugely beneficial when applications need to start and stop almost instantly, like in serverless functions or cloud-based microservices architectures. For instance, one of our microservices, native powered by Quarkus 3.2.7.Final, starts in just 0.677s. * Lower memory footprint: Applications' memory footprints can be significantly reduced with native images as they only include the runtime components actually used by the applications. This efficiency is important in cloud environments where resource usage directly affects costs. Real service memory usage Figure 1. Memory usage of a Quarkus native image * Easier distribution: As standalone executables, native images can be easily distributed and run on any environment without requiring the installation of a separate runtime. * Reduced container size: Being fully self-contained, the container images for native images are more efficient to distribute due to their reduced size. This leads to faster start-up times in containerized environments like Kubernetes. For example, the size comparison between Quarkus Native (85.1 MB), Quarkus Non-Native (648.4 MB) and Spring Boot (861.9 MB) provides a clear picture of the difference in resource efficiency between them. With Quarkus, you can compile your application into a native image by leveraging the GraalVM native-image compiler, allowing your Java applications to experience these advantages in cloud platforms, containerization, and serverless architectures due to their swift startup times and lower resource consumption. OPTIMIZING DEVELOPER PRODUCTIVITY Quarkus brings several benefits which enhance developer productivity, such as: 1. Live Coding: With no build time and deploy time, developers can test changes to the code instantaneously. 2. Zero configuration with Dev Services: Quarkus can automatically configure some services for development and testing purposes, enhancing efficiency. 3. Continuous testing: Continuous testing is implemented via the command line and the Dev UI, enhancing the quality of the end product without depending on third-party tools and processes. 4. Dev UI: Developers can configure extensions, monitor the application, and test components with great ease. 5. Unified config: All of the application's configurations are consolidated in one place, improving accessibility. 6. Standards-based EMBRACING QUARKUS EXTENSIONS Quarkus Extensions are pre-configured feature sets designed to simplify several common tasks during application development. They offer an efficient way to imbibe new capabilities or direct integrations in your project with minimum effort. In our organization, we managed to implement our internal extensions swiftly, effectively addressing maintenance issues and configuration incompatibilities we encountered earlier while trying to create native images. Today, we benefit from an extension hub that quells all previous concerns and enhances our productivity. While Quarkus extensions are powerful tools offering deep integration, optimization, and enhanced developer experience, it's essential to weigh the trade-offs and consider if simpler solutions like standard JAR libraries might suit the need better. LOOKING AHEAD In the graphical representation below, I want to illustrate the inherent relationship between the process of adopting Quarkus and the subsequent outcomes over time. Figure 2. Comparison of Difficulty/Cost and Ease of Ease-of-Use/Returns Over Time in Adopting Quarkus Features On the "Y-Axis", we define difficulty or cost in terms of story-points per sprint, reflecting the relative effort required for the features' implementation. This also represents costs in terms of time and resources spent in the adoption of Quarkus features. Simultaneously, ease-of-use/returns take into account metrics such as decreased debugging time, faster feature development, and improvements in team productivity post successful implementation. The graph clearly demonstrates that at the outset (tagged as "Begin" on the "X-Axis"), both the difficulty (illustrated in higher story points) and costs are at their peak, signifying a challenging initial phase. However, as we move along the timeline from "Begin" through "Middle" and onto "Future", we see a notable drop in story-points per sprint, indicating a reduced difficulty level and cost. In parallel to this, the ease-of-use and returns charted start at a comparatively low point at the beginning. These escalate gradually as we advance along the timeline towards "Middle" and "Future", showing a tangible increase in productivity and other gains from adopting and integrating Quarkus features into our practices. By the time we reach "Future", we see a substantial decrease in difficulty and cost, while the ease-of-use and returns have considerably increased. This dual progression effectively highlights the significant benefits of investing in the adoption of Quarkus, despite the initial challenges. Investing in Quarkus is a strategic maneuver towards creating efficient, scalable, and modern applications aptly suited for the cloud era. With its robust capabilities and supportive community, Quarkus is well-positioned to pioneer the future of cloud-native application development. The decision to adopt Quarkus is a significant leap towards optimizing for efficiency, scalability, and cutting-edge application performance that will provide us with a considerable competitive edge in the rapidly evolving tech landscape.
22 Apr 2024 12:00am GMT
19 Apr 2024
In this article, we will learn how to debug a Quarkus application using two popular Development Environments such as IntelliJ Idea and VS Studio. We'll explore how these IDEs can empower you to effectively identify, understand, and resolve issues within your Quarkus projects. Enabling Debugging in Quarkus When running in development mode, Quarkus, by default, ... The post appeared first on .
19 Apr 2024 8:24am GMT
18 Apr 2024
|
Airbnb's Extensive JavaScript Style Guide - It's been years since we mentioned this popular, opinionated style guide, but it keeps getting little tweaks and repairs and remains a handy resource nonetheless.
Airbnb
|
WorkOS: Enterprise-Grade Auth for Modern SaaS Apps - WorkOS supports both the foundational auth and complex enterprise features like SSO. It provides flexible and easy-to-use APIs, helping companies like Vercel, Loom, and Webflow become Enterprise Ready. Best of all, WorkOS User Management supports up to 1 million MAUs for free.
WorkOS sponsor
|
|
π Articles & Tutorials
|
|
RAG to Riches Developer Quest - Interact with AI-enhanced bots and learn to build your own RAG chatbot with Atlas Vector Search and Node.js.
MongoDB sponsor
|
|
CSS in React Server Components - An exploration of compatibility issues between React Server Components and CSS-in-JS libraries like styled-components.
Josh W Comeau
|
|
Next.js 14.2 Released - Approaching its eighth birthday, Next.js has passed 1 million monthly active developers and landed a release with support for using Turbopack to improve local development, memory usage, CSS and caching optimizations, improved error messages, and more.
Delba de Oliveira and Tim Neutkens
|
|
β³ A Blast from the Past
|
|
Visualizing Algorithms - This fantastic post is now ten years old, but I revisited it recently and it's such a joy. Mike Bostock (of D3.js fame) visually guides us through some algorithms using both demos and code.
Mike Bostock
|
|
18 Apr 2024 12:00am GMT
GRAN Software Solutions is a German company that designs and builds modern backend solutions. We work with large automotive clients and others to restructure and create new solutions. We also develop and offer SaaS tools to help us and others in our daily work. One such tool we built for ourselves and others is a time tracking application called . THE TIME TRACKING CHALLENGE We needed to create a time tracking application because the existing solutions on the market did not meet our specific requirements. They were either not designed for developers, lacked the simplicity we needed, or were loaded with unnecessary features. We wanted to build a tool that was perfectly tailored to our needs, using the extensive experience we had gained from working on client projects over the years. We also wanted to create a more modern and user-friendly design, which would be fun to use and incorporate newer technologies such as Quarkus. The main issue we faced with existing time tracking solutions was the lack of an easy way to switch between clients. We also found that they did not support quick actions or shortcuts, which we were used to, and there was no visual way to see the time entries we made during the day. Additionally, we wanted to track time within the context of contracts signed with our clients in terms of daily rates and contract caps. That's why we decided to create a custom solution to address all of these specific needs. DISCOVERING QUARKUS When we were choosing the technology stack to use for our backend, our main goal was to use technologies that we were already familiar with, such as the Kotlin programming language, Spring Boot framework, and Postgres database. We also wanted to select an ecosystem that could provide us with libraries for database connectivity, web client, caching, and other similar features. Additionally, we wanted to use a high-performance solution to keep our hosting costs low and avoid high memory requirements. After analyzing various solutions on the market, we decided to use the Quarkus framework as it met all of our requirements. OUR BACKEND DEVELOPMENT EXPERIENCE WITH QUARKUS: THE KEY FEATURES We have designed our application architecture to separate the frontend and backend parts. To secure our backend APIs in a modern and secure way, we opted to use JSON web tokens, and Quarkus has excellent support for them. We also use role-based security for our APIs, and Quarkus makes it easy for us to implement this. We have different roles in our application, such as regular users and admins, and this information is encoded in our JSON web tokens. Quarkus ensures that these tokens are not tampered with or manipulated when they reach our back-end systems. @RolesAllowed for authorization of our API endpoints @Path("/clients") @RolesAllowed("User") @Produces(MediaType.APPLICATION_JSON) @ApplicationScoped class ClientResource( private val getClientsHandler: GetClientsHandler, private val newClientHandler: NewClientHandler, We relied heavily on rich JSON support to model our data flexibly and delegate much of the functionality to Postgres itself to manipulate the data. This way, we could pass the already-built JSON objects back to the API client, which significantly reduced the time it took to make design decisions in the application code. Quarkus provided fantastic support for JSON object APIs. We believe that Postgres is the right place to perform data manipulations and aggregations, not the application code, due to performance and code maintenance reasons. Using JsonObject to pass our data in and out @GET @Produces(MediaType.APPLICATION_JSON) suspend fun getProfile() = db.preparedQuery( """select profile from "user" where email = $1""".trimIndent() ).execute().awaitSuspending().first().getJsonObject("profile") Although Quarkus primarily targets Java programming language, Kotlin support is also quite good. We used coroutines and suspending functions, which allowed for greater performance and much simpler code compared to some other asynchronous programming models that are available. Kotlin's structured concurrency enabled us to write seemingly sequential code but in reality, very performant asynchronous code. Quarkus provides excellent Kotlin extension methods built on top of existing asynchronous APIs such as Mutiny. We executed the database migration on application startup, which was very important for us. Fortunately, Quarkus has excellent Flyway support, so all our database migrations were in one place and executed during our backend booting process. This kept our database schema and data transparent and reproducible. Figure 1. Using Flyway to execute database migrations For our deployments, we use Kubernetes. Before using Quarkus, we described our application requirements using helm packaging, but with Quarkus, we opted for another approach as Quarkus offers a great Kubernetes extension. Instead of writing any code, we described our Kubernetes resources using an application.yaml file, keeping our complete application configuration in one place. This extension generated Kubernetes resource files behind the scenes, which we then applied to our Kubernetes cluster. This works well for us. Figure 2. Using the Kubernetes extension to generate Kubernetes resources For packaging our backend API, we used the Jib extension. To package our application in a container, all we had to do was use the application.yaml file and set all the required parameters such as image name tags repository, and so on. We didn't have to maintain the Docker file on our own, which was very convenient. Our time tracking application needs to send emails to our users and admins on various occasions. To keep things simpler, we decided not to go for any third-party API-driven email-sending approach. Instead, we send emails ourselves, and for that purpose, we use Qute email templates, which make composing and sending emails to our users very simple. This extension provides support for coding coroutines, allowing for non-blocking sending and higher throughput. Figure 3. Using Qute email templates to send emails DEVELOPMENT JOURNEY The Quarkus development process has been excellent so far. Compared to other frameworks like Spring Boot, Quarkus has a faster startup time and a smaller memory footprint. It also provides profiles, which allows us to have slightly different configurations or behaviors between environments. We can easily substitute some hard-to-run third-party services with local mocks, leaving the application code unchanged. Quarkus is also great in terms of configuration and how easily we can overwrite values stored in the application.yaml file with external environment variables. Although the hot reload mode didn't work well with Kotlin, I believe all the bugs related to it will be solved in upcoming releases. During development, we had to restart our running service most of the time for code changes to take effect. Our backend API functionalities took approximately a month and a half to complete. Considering that only two developers worked on the backend, I think it was a good result. In this phase of our product lifecycle, we decided against writing automated tests due to constantly revisiting requirements and our needs. Instead, we went for manual testing for now. Once our time tracking application gets more active users, we plan to start writing automated tests using Quarkus test support, including Testcontainers and others. Developing a full-blown API, including API security with JSON web tokens and authorization in place, having database migration automatically applied during application boot time, having a flexible and maintainable code base revolving around JSON, with the ability to package and deploy our API to our Kubernetes cluster, is quite an achievement for just a month and a half of work. CONCLUSION We are glad to share that using Quarkus, Kotlin, and Postgres as the foundation of our backend API has been a fun and productive experience for us. Quarkus's ability to experiment quickly and leverage ready-made components has made us confident that we made the right technological choice. Although there are some imperfections with hot reload and some quirks with Kotlin, we are waiting for the fixes to be made and have no doubt that Quarkus is the best solution for us. We are working smart and hard to bring new features to our time tracking application. To achieve this, we will continue to use the great features provided by Quarkus, which dramatically reduce the time needed to roll out our features quickly. We invite you to try our time tracker at .
18 Apr 2024 12:00am GMT
17 Apr 2024
jQuery's influence on the web will always be evident. When it was first introduced in 2006, jQuery became a fundamental tool for web developers almost immediately. It simplified JavaScript programming, making it easier to manipulate HTML documents, handle events, perform animations, and much more. Since then, it has played and continues to play a major β¦ Continue reading β
17 Apr 2024 5:00pm GMT
11 Apr 2024
|
Frontend Development Beyond React: Svelte - A surprisingly thorough article going deep into one developer's research into using Svelte to build modern front-end apps. If you've never experimented with Svelte, this is a good primer to the key concepts, tradeoffs, and techniques involved.
HΓ©la Ben Khalfallah
|
Add Excel-Like Spreadsheet Functionality to Your JavaScript Apps - SpreadJS is the industry-leading JavaScript spreadsheet for adding advanced spreadsheet features to your enterprise apps. Build finance, analysis, budget, and other apps. Excel I/O, 500+ calc functions, tables, charts, and more. View demos now.
SpreadJS from MESCIUS inc sponsor
|
|
zx v8.0: Write Better Shell Scripts with Node - A popular way to make shell scripting a more pleasant experience in Node with useful wrappers around child_process, argument escaping, and sensible defaults. v8.0 makes zx 20x smaller, faster, makes it easier to kill processes, pass input to commands & more.
Google
|
|
π Articles & Tutorials
|
|
On Developing Figma Plugins - Some interesting observations on the experience of creating Figma plugins in JavaScript, including how they're sandboxed and some implementation details of the author's own plugin.
Tom MacWright
|
|
React Server Components in a Nutshell - A quick overview of RSCs not all about Next.js, comparing the approach taken by several frameworks before sharing thoughts on the tech and why the smaller Waku framework is worth a look.
Paul Scanlon (The New Stack)
|
|
Some DevTools Tips and Tricks - Most developers barely scratch the surface of what DevTools can accomplish, says the author, who shares ten tips here.
Pankaj Parashar
|
|
PythonMonkey: A JavaScript Engine in the Python VM - If you need to use Python but also want to run JavaScript, this gives you a way to do it with the Mozilla SpiderMonkey JS engine embedded into the Python runtime with Python providing the host environment.
Distributive
|
|
Color.js 0.5: 'Let's Get Serious About Color' - A fantastic library for working with colors in the browser, following the latest specs. It's even been used by browsers to test their CSS Color 4/5 implementations.
Lea Verou and Chris Lilley
|
-
Mikro ORM 6.2 - TypeScript ORM for Node.js based on Data Mapper. SQL Server and libSQL/Turso join the list of supported databases.
-
Rspack 0.6 - Fast Rust-based web bundler.
-
Pixi.js 8.1 - The fast WebGL and WebGPU 2D graphics engine switches back to WebGL by default due to immature browser support.
-
Jotai 2.8 - Simple, flexible state management for React.
-
DOMPurify 2.5 - Fast, tolerant XSS sanitizer for HTML and SVG.
-
Reveal.js 5.1 - Framework for building presentations in HTML.
-
Xterm.js 5.5 - Create terminal experiences on the Web.
-
TIFF 6.0 - Pure JS TIFF image decoder.
-
Shiki 1.3 - Powerful syntax highlighter.
|
|
11 Apr 2024 12:00am GMT
04 Apr 2024
|
A Proposal to Add Signals to JavaScript - A (very) early stage proposal for bringing a new feature to ECMAScript/JavaScript: signals! The proposal brings aboard ideas from a swathe of popular frameworks and aims to align everyone and get us on the same page when it comes to working with state and making updates based upon changes to state. Rob writes more about the proposal here.
Rob Eisenberg and Daniel Ehrenberg
|
|
Bun 1.1 Released: Now Supports Windows Too - With the lighthearted codename of Bundows, the alternative server side runtime now runs directly on Windows 10 and up (plus WSL, macOS and Linux, of course). This is a key step in its adoption, with even features like Bun Shell happy on Windows out of the box. Node compatibility continues to improve with support for node:http2 and IPC support between Bun and Node processes.
The Entire Bun Team
|
|
IN BRIEF:
-
Samuel GroΓ of the V8 team explains the V8 Sandbox, a security mechanism designed to prevent memory corruption in the V8 engine impacting other memory in the process.
-
Dexie.js is a popular wrapper for IndexedDB and its creator has launched Dexie Cloud, a platform to store and synchronize data between apps.
-
Svelte's Rich Harris is 'shaken up' after a misunderstanding around 'self-closing' HTML tags and their effect on Svelte.
-
π€‘ There was a curious JS-themed April Fools prank where a .js TLD for domain names was 'announced'. Sadly, it's not true, but there is js.org if you want something vaguely similar.
-
An official update on the merging of Angular and Wiz.
RELEASES:
|
|
π Articles & Tutorials
|
|
What Even Is a JSON Number? - Despite the presence of standards around JSON, the answer is more complicated than you'd think, particularly when it comes to interfacing with other ecosystems and languages that aren't JavaScript.
Brian Terlson
|
|
The BFCache Explained - The back/forward cache ('bfcache') is a browser optimization that makes going back and forward in the browser a faster experience - it's been present for years and usually leaves you alone as a JavaScript developer, but there are things worth being aware of.
Sabatino Masala
|
|
04 Apr 2024 12:00am GMT
22 Mar 2024
NCache Java Edition with distributed cache technique is a powerful tool that helps Java applications run faster, handle more users, and be more reliable. In today's world, where people expect apps to work quickly and without any problems, knowing how to use NCache Java Edition is very important. It's a key piece of technology for both developers and businesses who want to make sure their apps can give users fast access to data and a smooth experience. This makes NCache Java Edition an important part of making great apps.
This article is made especially for beginners to make the ideas and steps of adding NCache to your Java applications clear and easy to understand. It doesn't matter if you've been developing for years or if you're new to caching, this article will help you get a good start with NCache Java Edition. Let's start with a step-by-step process to set up a development workstation for NCache with the Java setup.
22 Mar 2024 1:00am GMT
21 Mar 2024
Despite some notable shortcomings in the contemporary technology landscape, XML is still a powerful language offering key advantages in complex data storage scenarios.
Compared with a popular data interchange format like JSON, for example, XML's syntax places a greater emphasis on machine readability over human readability, making its error-checking process more efficient. Most importantly, XML is great at storing unique data types with multiple variables, whereas JSON is optimized for relatively simple and concise object storage. XML's advantages and disadvantages both stem from the fact that it's not a dedicated data interchange format like JSON at all; rather, it's a complex markup language (more similar to HTML) with powerful data interchange capabilities.
21 Mar 2024 12:00pm GMT
20 Mar 2024
I blogged about Java stream debugging in the past, but I skipped an important method that's worthy of a post of its own: peek. This blog post delves into the practicalities of using peek() to debug Java streams, complete with code samples and common pitfalls.
![Magnifying glass over code]()
Understanding Java Streams
Java Streams represent a significant shift in how Java developers work with collections and data processing, introducing a functional approach to handling sequences of elements. Streams facilitate declarative processing of collections, enabling operations such as filter, map, reduce, and more in a fluent style. This not only makes the code more readable but also more concise compared to traditional iterative approaches.
20 Mar 2024 10:00pm GMT
06 Feb 2024
jQuery 4.0.0 has been in the works for a long time, but it is now ready for a beta release! There's a lot to cover, and the team is excited to see it released. We've got bug fixes, performance improvements, and some breaking changes. We removed support for IE<11 after all! Still, we expect disruption β¦ Continue reading β
06 Feb 2024 4:43pm GMT
28 Aug 2023
jQuery 3.7.1 has been released! This release fixes a regression from jQuery 3.6.0 that resulted in rounded dimensions for <tr /> elements in Chrome and Safari. Also, a (mostly) internal Sizzle method, jQuery.find.tokenize that was on the jQuery object was accidentally removed when we removed Sizzle in jQuery 3.7.0. That method has been restored. As β¦ Continue reading β
28 Aug 2023 1:40pm GMT
JBoss Blogs
