Day: July 17, 2023

Marc Andreesen was one of the first few to foresee the recent software boom, with his long-standing quote — “In the future, every company will become a software company.” While the pandemic years fit perfectly into his predictions, the real question is: Where does all this software come from?

The answer is your developers. Software engineering teams are the frontrunner of the current software sprawl. Much has been already talked about what developers bring to modern software development and the SaaS world. They work at the intersection of product, business, and customer requirements, ensuring robust product delivery to end users with continuous feedback from all sides. The list of features worked by devs gets longer every month, making them an integral part of any product growth. 

In today’s digital world, cloud computing is necessary for businesses of all types and sizes, and Amazon Web Services (AWS) is undoubtedly the most popular cloud computing service provider. AWS provides a vast array of services, including CloudWatch and CloudTrail, that can monitor and log events in AWS resources.

This article will compare AWS CloudWatch and CloudTrail, looking at their features, use cases, and technical considerations. It will also provide implementation guides and pricing details for each.

I have already described how to secure a Spring Boot 2-based REST API with Keycloak here. Today, I would like to create a separate text with the same topic but for Spring Boot 3 — a newer, shiner version of Spring Boot.

Most of the Keycloak configuration and settings is one to one with the article for Spring Boot 2. I do not want to duplicate too much content so if anything is unclear I recommend going there.

We gotta talk about CSS! That’s my favorite thing! It’s always on the table for a good Chris’ Corner edition, but sometimes focusing on it entirely is best.

Klint Finley called it “The modern web’s underrated powerhouse” for GitHub’s publication The ReadME Project back in February, and I’m inclined to agree. Although the days of CSS being considered underrated are waning. I get the sense that plenty of people find it complicated or generally just don’t like it, but those same people still respect its power. There is also one big undeniable fact: every website uses it. All of ’em. And it controls nearly every aspect of how a website looks, which, ya know, if you care at all about how successfully your website does what it sets out to do, matters a whole heck of a lot.

Anyway, rather than listen to me prattle on about how good CSS is, let’s look at some interesting ideas pulled off in CSS, new things coming to CSS, dealing with browser support, and future ideas.

---

It used to be that if you used CSS to set the width and height of an image and the aspect ratio that those two numbers formed didn’t match the aspect ratio of the image, it would squish the image awkwardly. Almost certainly not the effect you want. But now we’ve got the object-fit property in CSS, and specifically the cover and contain values, which prevent the squishing. With cover, the image might crop, so you’re sending more image data than you needed to, perhaps, but you’ll be achieving the design you’re after.

With that as a foundation, let me let Henry Desroches take over in Using Focal Points, Aspect Ratio & Object-Fit To Crop Images Correctly. In conjunction with object-fit there is object-position which allows you to set an XY coordinate from where the image scales.

Try clicking different positions on the source image and see how the sized images change which part of the image they show. This is just good to know. If you’re ultimately cropping images, you don’t have to settle for the defaults.

---

You’d think “position this element over by this other element” would be easy peasy for CSS, but you’d be wrong. There has been no mechanism for that up until now. The new thing is called anchor positioning, and Jhey Tompkins has the scoop in Tether elements to each other with CSS anchor positioning.

The big obvious use case to all this for me is basically: tooltips powered by footnotes. Essentially I want bits of UI (a phrase, link, or [?] button) that can be hovered or otherwise interacted with to reveal a bit more information. But that information is elsewhere in the DOM. Wherever I want in the DOM that makes sense for my project. Finally, I’ll be able to do that (once is supported across all browsers or if I use the polyfill).

I had a little play with this myself, thanks to Jhey’s guidance in this post.

I didn’t get into all the scrolling stuff you have to think about or the @try style positioning, but I do think all that is very cool. Edge detection stuff is another thing that we’d have to lean on JavaScript to do normally, but never love having to do so.

---

As good as CSS has been lately with new features working across browsers, it’s still a thing we have to think about. Fortunately, CSS saw this coming long ago and has @supports rules that can help us conditionally apply CSS in supporting (or not) situations.

Stephanie Eckles has the most up-to-date information on all this in Testing Feature Support for Modern CSS.

An example I can think of is the kick-ass :has() selector. As I write, :has() isn’t supported in Firefox yet. So if we wanted to know that in CSS before we use it, we could do:

@supports selector(:has(a)) {
  /* styles when :has() is supported */
}

It is useful to think about what your plan is for detection, though. Like does it matter if Firefox doesn’t support :has() for what you are trying to do? Are you prepared to do it some other way if it’s not? As an example, I was talking to Eric Meyer the other day, and somehow table row/column highlighting came up, and he made a demo with :has().

Now you’d have to decide: how important is that effect? As written, in Firefox, just the cell you hover over highlights, so you could decide that’s fine, and then you don’t need any feature detection at all; you just let it fail. Alternatively, you could decide to use a @supports query in CSS and highlight the entire row if :has() isn’t supported, which is a similar effect (if not quite as cool).

Another decision you could make is to do the test in JavaScript and use a JavaScript-powered fallback if necessary. Good news, Stephanie has a JavaScript testing tool just for this. It uses a number of different techniques to report if a feature is supported or not. Ultimately you could use it for our :has() test like:

<script type="module">
  import * as SupportsCSS from "https://cdn.skypack.dev/supports-css@0.1.5";
  const tests = ["has"];
  SupportsCSS.init({ tests });

  if (!SupportsCSSTests.results.has) {
    document.head.insertAdjacentHTML(
      "beforeend",
      "<style>tr:hover { background: rgba(255,0,0,0.33); }</style>"
    );
  }
</script>

---

Ya know, just while we’re talking about feature detection in CSS, a typography-specific feature tester crossed my desk the other day, font-tech and font-format:

@supports font-tech(palettes) {
  .palette {
    display: block;
  }
}

@supports font-format(woff2) {
  div {
    display: block;
  }
}

Just interesting to me; I’ve never seen those specific functions before.

---

Wait, wait, I gotta do one more about feature detection. There are some things that you cannot detect in CSS, and is kind of a pain in the butt to detect in JavaScript also. Ahmad Shadeed made this point in Do we need CSS flex-wrap detection? The point has been made again and again that we need certain state detections like a :stuck selector for position: sticky; elements, and it sounds likely we’ll get that. But “is wrapped or not” is another form of state, I’d say. Ahmad’s use case was like… if a line in a flexbox layout wraps, it’s saying: “there isn’t room for these on one line”. But where that is is totally arbitrary based on content and element size. But if we knew exactly when that break was, we could, for example, use that exact moment to break a line of navigation into a hamburger rather than guessing at some magic number size. Strong point, I think.

---

I have an unnatural affinity for the “yellow fade technique”. It’s this idea that works with the :target selector in CSS and on-page anchor links. Imagine a table of contents where you click a link, and it jumps the page down (or scrolls, I suppose if you use scroll-behavior: smooth). How do you know exactly where the page is trying to take you to and draw your attention toward? The element is probably at the top of the page, but it might not be if the page is too short. The yellow fade technique just makes it way more clear. When that jump happens, that element becomes the :target, and you apply a background-color animation to it (light yellow!) that draws attention to it. It’s just nice, I think. There are some classic examples on CodePen, naturally.

The idea can also be applied to an element being added to the DOM, drawing attention to the fact that it just appeared. That’s what Bramus Van Damme does in The Yellow Fade Technique with Modern CSS using @starting-style.

Erm… @starting-style, what’s that? It’s basically built for the yellow fade technique. 😍.

div {
  transition: background-color 0.5s;
  background-color: transparent;

  @starting-style {
    background-color: yellow;
  }
}

With that, you don’t need a once-running @keyframes which ends up being more verbose and harder to understand. This way the transition essentially runs once on <div>s being added to the DOM. So I guess it’s not as perfect for the table of contents use-case, but it’s still pretty cool. Now I’m thinking about other DOM-entrance animations, like list items that slide in, or modals that fade in.

---

Sometimes we get new CSS stuff, and it’s just great right on the surface. Oh, the oklch() color function? Neat, it can do vibrant P3 colors. Neat, it has perceptually uniform lightness. Neat, the gradient interpolation is arguably nicer for some color pairings.

But then, over time, it turns out it’s how the new CSS feature is combined and interacts with other features that makes that feature shine even more. Aww, that was sweet, wasn’t it? We’re all better with a little help from our friends.

That’s what I was thinking about reading Adam Argyle’s A color-contrast() strategy for complimentary translucent backgrounds. If you haven’t seen color-contrast() yet, it’s a function that will pick the most visually contrasting color from a list of colors against a given color. That given color is probably a --custom-property meaning it can change and thus you don’t know ahead of time what the most contrasting color is. That’s awesome! But Adam takes it a little bit further. He wants to kick up the contrast even more by putting a slightly transparent black or white color behind the text.

html {
  --bg: hsl(var(--hue) 50% 50%);
}
  
h1 {
  --text: color-contrast(var(--bg) vs black, white);
  color: var(--text);
  background: hsl(0 0% 0% / 40%);
}
  
@supports (background: hsl(from red h s l)) {
  h1 {
    background: oklch(from color-contrast(var(--text) vs black,white) l c h / 40%);
  }
}

So cool. So individually, color-contrast() is neat, OKLCH is neat, @supports is neat, and the relative color syntax is neat, but combined, they really shine.

The post Chris’ Corner: More Like CSBest appeared first on CodePen Blog.

In this article, I'll walk you through another important concept of Generative AI Prompt Engineering. Prompt Engineering in the field of AI, involves the creation of concise pieces of text or phrases designed according to specific principles. These prompts are then utilized with Large Language Models (LLMs) to generate output content effectively. The process of prompt engineering serves as a crucial building block because improperly constructed prompts can lead to LLM models like ChatGPT generating illogical, meaningless, or out-of-context responses. Therefore, it is considered a best practice to validate the input texts passed to the LLM model's API based on well-defined principles of prompt engineering.

Depending on the intent or purpose of the input phrases, the model can exhibit various capabilities. These may include summarizing extensive pools of texts or content, inferring or clarifying topics, transforming the input texts, or expanding upon the provided information. By adhering to the principles of prompt engineering, the AI model can harness its full potential while ensuring accurate and contextually relevant output.

In today's world, databases are valuable repositories of sensitive information, and attackers are always on the lookout to target them. This has led to a rise in cybersecurity threats, making it essential to have proper protection measures in place. Oracle Maximum Security Architecture (MSA) is one such solution that provides end-to-end security for databases.

In this article, we will explore the various components of Oracle MSA, how it works, and how it can help businesses protect their sensitive data. We will also look into the different types of attacks that target databases and how Oracle MSA can help prevent them.

Starting with Kubernetes can be daunting, as the K8s landscape continuously evolves and new concepts and terminology emerge. Here, we break down the Kubernetes implementation process into clear and concise steps to help you get started. 

Unlock the potential of Kubernetes and embark on an exciting adventure in the world of container orchestration! So, let's dive in and explore how to implement Kubernetes step-by-step.

Veteran engineers likely remember the days of early software development, when software releases were delayed until they included all desired code complete features. This method resulted in extremely long wait times for users, not to mention security concerns and errors that were often treated as an afterthought and addressed through patches and updates. Worse, developers often released these updates on an annual or semiannual basis, creating significant delay between the recognition of an error and its resolution.

Agile development methodologies and continuous deployment (CD) have since arisen as the antithesis of slow, buggy releases. Agile development and CD enable faster updates with fewer errors by combining automation, continuous development, and integration to streamline the software development and delivery process.

In this article, we will look at how to configure GitLab notifications in Telegram to receive information about successful deployment and failures during the development phase. This is especially useful for developers, DevOps engineers, and PMs, as it allows you to stay up to date on GitLab activity and respond immediately to crashes.

Let’s get started with what we want to do step-by-step:

This is one of the most interesting Java test tasks I have encountered. It is not an abstract problem from a curriculum but rather a scenario that closely resembles real-life use cases. In this article, I'm going to analyze the task, provide a breakdown of the requirements, and justify my decisions. You can find a link to the source code at the end of the article.

Disclaimer

I received this task almost two years ago. The bank should have already changed the assignment; therefore, I believe it is fair to discuss this task openly.

Agile teams thrive on continuous improvement and adaptability. Self-assessment isn’t just a health check measuring tool but a compass guiding teams toward their potential. It enables teams to understand their strengths, identify areas of improvement, and delve deeper into work dynamics beyond mere output.

The true essence of self-assessment in Agile is fostering transparency, collaboration, and relentless improvement. It’s not an audit; it’s a mirror reflecting a better version of your Agile team.

Does the emergence of feature flags affect the interpretation and utility of DORA metrics?

On this week’s episode of Dev Interrupted, host Dan Lines and Ariel Perez, VP of Engineering at Split.io, discuss the state of DORA metrics and whether they need reimaging in a world of feature flags. Listen as Ariel explains why he believes feature flags are more than a tool and have begun to reshape our understanding of software development and the metrics we use to measure it.

Dan and Ariel also touch on how feature flags can drastically reduce lead time and mean time to recover and conclude their chat with an intriguing look at the granular nature of control in the modern software engineering landscape, where the unit of control has shifted from the application as a whole to individual features.

The proliferation of cross-platform app development is the new prevalent trend, witnessing widespread adoption as approximately one-third of mobile application developers opt for cross-platform frameworks as a compelling alternative to native apps. However, achieving optimal efficiency in cross-platform development presents formidable challenges, encompassing factors such as platform fragmentation, varying UI/UX requirements, performance optimization, and managing platform-specific features. 

Amidst these complexities, code sharing emerges as a pivotal factor in surmounting challenges and maximizing efficiency. Strategically sharing code across multiple platforms, developers can streamline development efforts, minimize duplication, and expedite time-to-market, ultimately empowering them to deliver high-quality cross-platform applications that exhibit native-like experiences on diverse devices. 

In this article, we will explore in-depth how query parameters can be leveraged to improve the efficiency and effectiveness of data filtering in REST APIs. So, let's dive in and discover how to harness the power of query parameters to enhance the performance and user experience of your API!

Importance of Data Filtering In REST APIs

Data filtering is of utmost importance in REST APIs as it provides developers with the ability to retrieve only the necessary information from a vast dataset. By filtering data based on specific criteria, developers can optimize the performance of the API and reduce the amount of data transferred over the network. This not only enhances efficiency but also improves the overall user experience by allowing clients to customize the response according to their specific needs. In applications dealing with large datasets, data filtering becomes crucial for managing and processing information effectively. REST APIs with filtering capabilities enable developers to work with subsets of data, making it easier to handle and manipulate large datasets efficiently. Additionally, data filtering in REST APIs plays a vital role in reducing network traffic by transmitting only the filtered data, resulting in faster response times and improved performance. It also contributes to scalability and resource optimization as it minimizes server load, making it easier to scale the API in high-traffic or resource-constrained environments.

Service Meshes have been gaining a lot of popularity lately, more so amongst Spring and Java developers who wish to address cross-cutting concerns. But are you wondering what exactly Service Meshes are? What are some of the popular types out there? And most importantly, what kind of problems do they actually solve? Well, look no further! This blog is here to provide you with the answers you seek.

What Is a Service Mesh? 

A service mesh is a dedicated infrastructure layer that helps manage communication between the various microservices within a distributed application. It acts as a transparent and decentralized network of proxies that are deployed alongside the application services. These proxies, often called sidecars, handle service-to-service communication, providing essential features such as service discovery, load balancing, traffic routing, authentication, and observability. 

Apache Spark is a leading platform in the field of big data processing, known for its speed, versatility, and ease of use. However, getting the most out of Spark often involves fine-tuning and optimization. This article delves into various techniques that can be employed to optimize your Apache Spark jobs for maximum performance.

Understanding Apache Spark

Apache Spark is a unified computing engine designed for large-scale data processing. It provides a comprehensive open-source platform for big data processing and analytics with built-in modules for SQL, streaming, machine learning, and graph processing.

The digital-first era has undoubtedly broadened the horizons of possibilities but has eventually increased the threat vector and created new vulnerabilities. 

Whether we talk about phishing attacks or modern brute-force attacks where individuals' identities are compromised, ignoring the importance of private security could be the worst thing ever.