Masonry layout, on the web, is when items of an uneven size are laid out such that there aren't uneven gaps. I would guess the term was coined (or at least popularized) for the web by David DeSandro because of his popular Masonry JavaScript library, which has been around since 2010.
JavaScript library. Nothing against JavaScript, but it's understandable we might not want to lean on it for doing layout. Is there anything we can do in CSS directly these days? Sorta.
Flexbox can do vertical columns with ragged endings too
But it's not quite as clever, because you'll need to set a height of some kind to get it to wrap the columns. You'll also have to be explicit about widths rather than having it decide columns for you.
But it's doable and it does auto space the gaps if there is room.
If it's just the uneven brick-like look you're after, then horizontal masonry is way easier. You could probably even float stuff if you don't care about the ragged edge. If you wanna keep it a block... flexbox with allowed flex-grow is the ticket.
CSS grid is very amazing and useful in a CSS developer’s everyday life, but it's not really designed for masonry style layouts. CSS grid is about defining lines and placing things along those lines, where masonry is about letting elements end where they may, but still exerting some positional influence.
Balázs Sziklai has a nice example of auto-flowing grids that all stack together nicely, with pretty good horiziontal ordering:
But you can see how strict the lines are. There is a way though!
Grid + JavaScript-maniplated row spans
Andy Barefoot wrote up a great guide. The trick is setting up repeating grid rows that are fairly short, letting the elements fall into the grid horizontally as they may, then adjusting their heights to match the grid with some fairly light math to calculate how many rows they should span.
What people generally want is column-stacking (varied heights on elements), but with horizontal ordering. That last grid demo above handles it pretty well, but it's not the only way.
Jesse Korzan tackled it with CSS columns. It needs JavaScript as well to get it done. In this case, it shifts the elements in the DOM to order them left-to-right while providing a horizontal stack using a CSS columns layout. This introduces a bit of an accessibility problem since the visual order (left-to-right) and source order (top-to-bottom) are super different & dash; though perhaps fixable with programmatic tabindex?
I’m a huge fan of CSS Grid and I use it on pretty much every project these days. However, there’s one part of it that makes things much more complicated than they really ought to be: the lack of subgrids. And in this post on the matter, Ken Bellows explains why they’d be so gosh darn useful:
But one thing still missing from the Level 1 spec is the ability to create a subgrid, a grid-item with its own grid that aligns in one or both dimensions with the parent grid. It was originally planned to be in Level 1, but the working group decided they needed more time to work out the details, so it was removed, and it will ship in CSS Grid Layout Module Level 2, which seems to be nearing completion.
There has been a lot of discussion over the last 2 years about the use cases for subgrid, how it should be implemented, and even some debate over whether you even need it. A lot of that discussion was centered around two other approaches that can handle many of the same problems as subgrid: nested grids and display: contents
I remember one of the very first websites I worked on was much like the demo that Ken uses as an example, but this was way back in 2012 and grid didn’t exist yet. Sadly, I had to write a lot more CSS than I felt was necessary to get elements in one div to line up with elements in another. Anyway, this article kinda riffs off of Rachel Andrew’s post about subgrid and what problems it would help solve which is definitely worth checking out, too.
A REST API is a service on the web that works on representational state transfer technology. It is basically a communication’s approach that has usually been employed in the development of web services.
An API based on REST uses HTTP to make requests for functioning with data. REST uses very little bandwidth and is, therefore, more preferable for internet usage. API is the aptest code through which two different software programs can communicate with each other.
The process was laid out how I've approached the use case and how I've used successful portfolio solutions as the basis for researching a generic architectural blueprint. The only thing left to cover was the order in which you'll be led through the blueprint details.
In this article, we will see the steps to set up a Spring Boot application with PostgreSQL. We will have a simple CRUD operation in Postgres Database by exposing the application via Rest API. We will use POSTMAN to test the application.
Setting up Postgres Server
Download the Postgres server from the link: https://www.postgresql.org/download/
Run the installer. It will also ask the password for the superuser: postgres
Click on pgAdmin4.exe located inside the PostgreSQL folder inside Program Files.
For the past few months, I've been digging into integration as the key to the omnichannel experience.
It's an interesting challenge in that I've been given the mission of creating architectural content based on common solution adoption patterns. That's very different from most of the traditional marketing activities usually associated with generating content for the sole purpose of positioning products for solutions. When you're basing the content on actual execution in solution delivery, you're cutting out the chuff.
General Token that represents a string that has no meaning for the client (e.g., 2YotnFZFEjr1zCsicMWpAA). That type of bearer token cannot be validated by the Resource Server without direct communication with an Authorization Server.
JWT Token represents the JSON object with statements (claims) about the user and token. The JWT token contains three separate parts: header, payload, and signature — each of them are base64-encoded for transferring. JWT tokens are not a part of core OAuth2 specification but mandatory for use with OpenID Connect. JWT token is the most popular way to exchange information about current authentication between microservices. More details can be found here.
Token Validation Methods
OAuth2 tokens can be validated using the following methods:
If you follow my blog regularly then you may be wondering why am I writing an article to tell people to learn Python? Didn’t I ask you to prefer Java over Python a couple of years ago?
Well, things have changed a lot since then. In 2016, Python replaced Java as the most popular language in colleges and universities and has never looked back.
The Apache Spark + Alluxio stack is getting quite popular particularly for the unification of data access across S3 and HDFS. In addition, compute and storage are increasingly being separated causing larger latencies for queries. Alluxio is leveraged as compute-side virtual storage to improve performance. But to get the best performance, like any technology stack, you need to follow the best practices. This article provides the top 10 tips for performance tuning for real-world workloads when running Spark on Alluxio with data locality, giving the most bang for the buck.
A Note on Data Locality
High data locality can greatly improve the performance of Spark jobs. When data locality is achieved, Spark tasks can read in-Alluxio data from local Alluxio workers at memory speed (when ramdisk is configured) instead of transferring the data over the network. The first few tips are related to locality.
There is no hard and fast rule to say this is the exact DevOps path to success, but we can always draw some experimental and hypothetical ideas and create a DevOps plan accordingly. In general, doing DevOps right means approaching DevOps in a systematic, platform-centric fashion and letting the culture fall into place naturally. Fix the root causes, and the symptom will go away. Whatever we call it, the end goal is to make the process of software development and delivery more efficient and merge dev and ops for a smooth business operation. Whatever the definition of DevOps is, but the ideology behind is the same.
Just to make it more clear, embracing DevOps means that you are willing to change fast, develop fast, test fast, fail fast, recover fast, learn fast, and push the products fast to the market. The primary goal of DevOps is simple: Ship software updates frequently, reliably, and with better quality and moreover, DevOps is a mental model transformation of the entire organization for better organizational agility, other words..it’s about delivery Nirvana.
Time series metrics reporting and alerting is an essential tool when it comes to monitoring production services. Graphs help you monitor trends over time, identify spikes in load/latency, identify bottlenecks with constrained resources, etc. Dropwizard Metrics is a great library for collecting metrics and has a lot of features out of the box including various JVM metrics. There are also many third-party library hooks for collections metrics on HikariCP connections pools, Redis client connections, HTTP client connections, and many more.
Once metrics are being collected we need a time series data store as well as a graphing and alerting system to get the most out of our metrics. This example will be utilizing Grafana Cloud which offers cloud-hosted Grafana, a graphing and alerting application that hooks into many data sources, as well as two options for time series data sources Graphite and Prometheus. StubbornJava has public facing Grafana dashboards that will continue to add new metrics as new content is added. Take a look at the StubbornJava Overview dashboard to start with.
I don’t really like talking about “productivity.” The very word sounds callous to me, as if it was invented by some micromanagement freak that wants to squeeze every last drop of energy from their employees.
Instead, let us talk about working smarter, not harder — or, in other words, about avoiding burnout in the burnout-prone IT world.
In all of the excitement about CSS Grid Layout and Flexbox, another layout method is often overlooked. In this article I’m going to take a look at Multi-column Layout — often referred to as multicol or sometimes “CSS Columns”. You’ll find out which tasks it is suited for, and some of the things to watch out for when making columns.
What Is Multicol?
The basic idea of multicol, is that you can take a chunk of content and flow it into multiple columns, as in a newspaper. You do this by using one of two properties. The column-count property specifies the number of columns that you would like the content to break into. The column-width property specifies the ideal width, leaving the browser to figure out how many columns will fit.
It doesn’t matter which elements are inside the content that you turn into a multicol container, everything remains in normal flow, but broken into columns. This makes multicol unlike other layout methods that we have in browsers today. Flexbox and Grid for example, take the child elements of the container and those items then participate in a flex or grid layout. With multicol, you still have normal flow, except inside a column.
In the below example I am using column-width, to display columns of at least 14em. Multicol assigns as many 14em columns as will fit and then shares out the remaining space between the columns. Columns will be at least 14em, unless we can only display one column in which case it may be smaller. Multicol was the first time that we saw this kind of behavior in CSS, columns being created which were essentialy responsive by default. You do not need to add Media Queries and change the number of columns for various breakpoints, instead we specify an optimal width and the browser will work it out.
The column boxes created when you use one of the column properties can’t be targeted. You can’t address them with JavaScript, nor can you style an individual box to give it a background color or adjust the padding and margins. All of the column boxes will be the same size. The only thing you can do is add a rule between columns, using the column-rule property, which acts like border. You can also control the gap between columns using the column-gap property, which has a default value of 1em however you can change it to any valid length unit.
That is the basic functionality of multicol. You can take a chunk of content and split it into columns. Content will fill the columns in turn, creating columns in the inline direction. You can control the gaps between columns and add a rule, with the same possible values as border. So far so good, and all of the above is very well supported in browsers and has been for a long time, making this spec very safe to use in terms of backwards compatibility.
There are some further things you might want to consider with your columns, and some potential issues to be aware of when using columns on the web.
Spanning Columns
Sometimes you might like to break some content into columns, but then cause one element to span across the column boxes. Applying the column-span property to a descendent of the multicol container achieves this.
In the example below, I have caused a <blockquote> element to span across my columns. Note that when you do this, the content breaks into a set of boxes above the span, then starts a new set of column boxes below. The content doesn’t jump across the spanned element.
The column-span property is currently being implemented in Firefox and is behind a feature flag.
Be aware that in the current spec, the values for column-span are either all or none. You can’t span just some of the columns, but you can get the kind of layout you might see in a newspaper by combining multicol with other layout methods. In this next example, I have a grid container with two column tracks. The left-hand track is 2fr, the right-hand track 1fr. The article in the left-hand track I have turned into a multicol container with two tracks, it also has a spanning element.
On the right, we have an aside which goes into the second Grid column track. By playing around with the various layout methods available to us, we can figure out exactly which layout method suits the job at hand — don’t be afraid to mix and match!
If you have content containing headings, then you probably want to avoid the situation where a heading ends up as the last thing in a column with the content going into the next column. If you have images with captions then the ideal situation would be for the image and caption to stay as one unit, not becoming split across columns. To deal with these problems CSS has properties to control where the content breaks.
When you split your content into columns, you perform what is known as fragmentation. The same is true if you split your content between pages, such as when you create a stylesheet for a print context. Therefore, multicol is closest to Paged Media than it is to other layout methods on the web. Because of this, for several years the way to control breaks in the content has been to use the page-break- properties which were part of CSS2.1.
page-break-before
page-break-after
page-break-inside
More recently the CSS Fragmentation specification has defined properties for fragmentation which are designed for any fragmented context, the spec includes details for Paged Media, multicol and the stalled Regions spec; Regions also fragments a continuous piece of content. By making these properties generic they can apply to any future fragmented context to, in the same way that the alignment properties from Flexbox were moved into the Box Alignment spec in order that they could be used in Grid and Block layout.
break-before
break-after
break-inside
As an example, I have used break-inside avoid on the <figure> element, to prevent the caption being detached from the image. A supporting browser should keep the figure together even if that causes the columns to look unbalanced.
Unfortunately, support for these properties in multicol is pretty patchy. Even where supported they should be seen as a suggestion due to the fact that it would be possible to make so many requests while trying to control breaking, that essentially the browser can’t really break anywhere. The spec does define priorities in this case, however it is probably more useful for you to control only the most important cases.
The Problem Of Columns On the Web
One reason why we don’t see multicol used much on the web is the fact that it would be very easy to end up with a reading experience which made the reader scroll in the block dimension. That would mean scrolling up and down vertically for those of us using English or another vertical writing mode. This is not a good reading experience!
If you fix the height of the container, for example by using the viewport unit vh, and there is too much content, then overflow will happen in the inline direction and so you get a horizontal scrollbar instead.
Neither of these things are ideal, and making use of multicol on the web is something we need to think about very carefully in terms of the amount of content we might be aiming to flow into our columns.
Block Overflow Columns
For Level 2 of the specification, we are considering how to enable a method by which overflow columns, those which currently end up causing the horizontal scrollbar, could instead be created in the block direction. This would mean that you could have a multicol container with a height, and once the content had made columns which filled that container, a new set of columns would be created below. This would look a little like our spanning example above, however, instead of having a spanner causing the new column boxes to start, it would be the overflow caused by a container with a restriction in the block dimension.
This feature would make multicol far more useful for the web. While we are a little way off right now, you can keep an eye on the issue in the CSS Working Group repo. If you have additional use cases for this feature do post them, it can really help when designing the new feature.
What Is Multicol Useful For Today?
With the current specification, splitting all of your content into columns without consideration for the problems of scrolling isn’t advised. However, there are some cases where multicol is ideal on the web. There are enough uses cases to make it something you should consider when looking at design patterns.
Collapsing Small UI Or Text Elements
Multicol can be useful in any place where you have a small list of items that you want to take up less space. For example a simple listing of checkboxes, or a list of names. Often in these scenarios, the visitor is not reading down one column and then going back to the top of the next, but scanning the content for a checkbox to click or an item to select. Even if you do create a scrolled experience, it may not be an issue.
There are times when we design a site where we know that some piece of content is relatively small, and will fit on the majority of screens without causing unwanted scrolling. I’ve used multicol on Notist presentation pages, for the introduction to a talk.
On the Equfund website, you can see how different HTML elements remain in normal flow while displayed inside columns. (Image source) (Large preview)
To avoid the possibility of very small screens causing scrolling, remember that you can use media queries to check for height as well as width (or in a logical world, block as well as inline). If you only enable columns at a breakpoint which has a min-height large enough for their content, this can save users of very small devices having a poor scrolling experience.
Masonry-Like Display Of Content
Another place where Multiple-column Layout works beautifully is if you want to create a Masonry type of display of content. Multicol is the only layout method that will currently create this kind of layout with unequal height items. Grid would either leave a gap, or stretch the items to make a strict two-dimensional grid.
In this design by Veerle Pieters, multicol is used to layout multiple boxes or cards as columns. (Large preview)
Grid And Flexbox Fallbacks
The column- properties can also be used as a fallback for Grid and Flex layout. If you specify one of the properties on a container, then turn that container into a Flex or Grid layout by using display: flex or display: grid any column behavior will be removed. If you have, for example, a cards layout that uses Grid Layout, and the layout would be readable if it ran in columns rather than across the page, you could use multicol as a simple fallback. Browsers that do not support Grid will get the multicol display, those which support Grid will get the Grid Layout.
Don’t Forget Multicol!
Fairly frequently I answer Grid and Flexbox questions where the answer is to not use Grid or Flexbox, but instead to look at Multicol. You probably won’t use it on every site, but when you come across a use case it can be really helpful. Over at MDN there are useful resources for multicol and the related fragmentation properties.
If you have used multicol on a project, perhaps drop a note in the comments, to share other ways in which we can use the feature.
Created by Robert Harm in Austria, MapsMarker Pro is a WordPress plugin that allows you to pin, organize, and share places on your WordPress blog or website.
Made as an alternative to gigantic, proprietary mapping companies with questionable privacy policies, MapsMarker Pro integrates with Google Maps, Google Earth, OpenStreetMap, Bing Map, and more; allowing you to then pin locations, display itineraries, or showcase nearby places of interest.
In 2019, it’s pretty rare to find a serious website that doesn’t display at least one map. Most sites, such as Netzen, are using maps to display their offices’ locations.
But there’s much more you can do with MapsMarker Pro.
Key features
MapsMarker Pro is loaded with useful features that will allow you to do more or less anything as long as you have a need to display maps and markers or share places on your site. Here is a quick list of my favorite features of the plugin.
As you probably already know, nowadays the majority of your site traffic is coming from handheld devices as such as smartphones or tablets. Therefore, it is a must in terms of ease of use and SEO that your website loads quickly and is easy to use on a smaller device.
MapsMarker Pro is definitely taking responsiveness into account. Maps created with the plugin are fast and easy to use on any mobile device – which is certainly a good thing as visitors like to check maps to discover interesting places around them. And as we have mentioned SEO, MapsMarker Pro is SEO-optimized.
Integrates with Google Maps, Google Earth, OpenStreetMap, etc.
Another feature I’m a big fan of is how well MapsMarker Pro integrates with the most popular maps. You can use Google Maps as it is by far the most common map type, but you can painlessly use many other maps such as OpenStreetMap or Bing Map. It’s up to you!
Translated to 46 languages
Thanks to over 100 contributors from all around the world, MapsMarker Pro is available in 46 languages. While I haven’t checked the quality of the available translations as I primarily use English online, this is clearly a great feature as maps are chiefly designed for a particular place, where people don’t necessarily use English.
No need for API keys
If you have already worked with Google Maps or a similar map service, you know the need for API keys. While obtaining and using API keys is generally a painless process, the fact that MapsMarker Pro doesn’t require additional API keys with included keyless geocoding providers Algolia Places and Photon@Mapsmarker which is good news as it will make you save time and effort.
Probably the most complete plugin of its kind
While there are quite many options for creating maps and markers, MapsMarker Pro is probably the most complete solution. If your site is running on WordPress, using the plugin will save you a lot of time and hassle as compared to setting up a more generic solution.
Exclusive CatsWhoCode deal: 10% off
If you are interested to try MapsMarker Pro on your website, here’s some good news! MapsMarker Pro has provided an exclusive discount for all CatsWhoCode readers.
Simply head over the pricing page and pick any license you like. At checkout, use coupon CATSWHOCODE to receive 10% off your purchase.
Conclusion
So, what to think about MapsMarker Pro? Its strong point is definitely the number of useful features that allow you to do basically anything you can think of, as long as it’s based on maps and markers, from simply displaying a map of your company office’s area to complex maps with filtered markers.
As for the weak point, I’d say the overall design could be improved. This, of course, doesn’t change anything to the functionality of the plugin, but a little eye candy never hurts.
In conclusion, I can affirm that MapsMarker Pro is a safe choice for any website owner looking for a map/marker solution that works out of the box and provides all the options you might need.
DynamoDB is a NoSQL database provided by AWS, and in the same way as MongoDB or Cassandra, it is very suitable to boost horizontal scalability and increase development speed.
Main Features
Fully managed NoSQL.
Document or Key-Value.
Scales to any workload. DynamoDB allows you to auto-scaling, so the throughput adapts to your actual traffic.
Fast and consistent.
Provides access control.
Enables Event Driven Programming.
Components
Tables. Catalog
Items. Group of attributes
Attributes. Data elements
Partition Key. Mandatory, Key-Value access pattern. Determines data distribution
Sort Key. Optional. Model 1:N relationships. Enables rich query capabilities
Avoid relational design patterns, and instead, use one table to reduce round trips and simplify access patterns. Identify Primary Keys and define indexes for secondary access patterns.
Select a strong Partition Key with a large number of distinct values. Do not use things like Status or Gender. Use UUID, CustomerId, DeviceId...
Items are uniformly requested and randomly distributed.
Select Sort Keys which follows a model 1:n and n:n relationships.
Use efficient and selective patterns for Sort Keys. Query multiple entities at the same time to avoid many round trips.
The use of AI in policing to date has largely been in areas such as facial recognition and helping to deploy resources in the most effective ways, but a recent study led by Northumbria University highlights how it can also help to crack unsolved crimes, especially by providing insights into the weapons used in committing the crime.
“Machine learning uses a series of algorithms to model complex data relationships,” the authors say. “Through careful fine-tuning, these can be applied to predict important characteristics of the ammunition used in a particular shooting event from those of the respective gunshot residue (GSR) deposited on surrounding surfaces or items, such as spent cases, wounds, and, potentially, also the shooter’s hands.”
React is a JS library that is used to build user interfaces. It is mostly used in making single-page and mobile applications.
Webhook is a very friendly and helpful way to get notified when something happens. In a web application, when something happens or an event occurs a message is posted via URL. Sometimes, you only need data when something happens, otherwise, you don't require any data. In conventional ways, a web application keeps fetching data from the database rather than waiting for any event that overwhelms the server by compromising more resources. Webhooks gives relaxation to the server and notifies when some event happens.
