RHCSA: Finding files and directories; mass operations on files

Extracted from Professor Nikolai Bezroukov unpublished lecture notes.

Copyright 2010-2018, Dr. Nikolai Bezroukov. This is a fragment of the copyrighted unpublished work. All rights reserved.

The Linux find command searches for files that meet specific conditions such as files with a certain name or files greater than a certain size. Like grep find  can be implemented in any scripting language, but this is a more difficult task. If we are talking about shell find is similar to the following ls command piped into a loop, but of course it is more sophisticated, powerful and efficient that this script (here variable $MATCH contain the condition string for which we search):

ls --recursive | while read FILE ; do
     # test file for a match
    if [[ $MATCH ]] ; then
       printf "%s\n" "$FILE"
    fi
done

This script recursively searches directories under the current directory, looking for a filename that matches some condition called MATCH.

From the point of view of computer science find is an interpreter of its own language for specifying queries, which is pretty flexible and powerful but is highly idiosyncratic -- it is used only in find.

This is a unique case when on command line you specify not a set of options, but a query in an application-specific language. The order of components (called predicates) is important. Each predicate iether checks for specific condition (in this case it returns true of false for each file checked), or perform specific action on file that already "passed" previous conditions (in this case it is always returns true).  While essentially any find query is a logical expression, we can also can view it as a pipeline, when each check serves as a filter and cuts file that do no satisfy specified by it criteria. 

Using "find application specific language you can create complex logical expressions describing the qualities of the files, By default they are connected with AND, but if needed you can also specify set of expressions connected by OR logical operation.

Some predicates are, in essence, a regular options which change the overall behavior of find (for example, option mount prohibits following mound points in filesystem traversal). By default find executes the action -print at the end sending the result to STDIN. There are several other  "actions" like -ls or -exec  .  While file can's accept stdin as input stream -- it generated input steam internally by traversing the filesystem, it can pass it s output to the pipe. In this sense it can be called "semi-filter". And in this role it is widely used as the first stage in pipes.

Find predicates

The most commonly used predicate in find is  -name, which compares the name of the file (without path) with a string or regex and returns true or false as a result of this comparison. If you want to evaluate regular expression against the whole path you need to use the predicate -regex  instead.

Theoretically the type of regex in find is user-definable and can be changed with the option -regextype. which allows file  types of regex:

• two "normal":  posix-basic(the default), posix-extended (the one that we studied in grep )
• three "esoteric": emacs ,  posix-awk,    posix-egrep

The problem is that in version of find that I tested this option does nothing, and the only type of regex find accepts is basic regex. For example

find -regextype posix-extended /etc -name '^[a-z].*\.[0-9]+$'> # -- DOES NOT WORK. Should find all files in /etc that start with the letter and have numeric suffix

If regular expression is specified, is should be enclosed in quotation marks to prevent the shell from expanding it before the find command:

find /etc -name "*.conf"

The example above find will list names of all objects in the /etc directories  (file, directories, symlinks, etc) that ends with .conf. We probably do not need to list directories and symlinks, so we better add option -type  to limit search to just regular files. The -type f  is the most common option used is find searches. The type can also be b (block device), c (character device), d (directory), p (pipe), l (symbolic link), or s (socket).

find / -name "*.conf"  -type f

In this example the two predicates  -name "*.conf" and -type f  form a simple find expression.  As we already mentioned above,  individual predicates in the expression are connected with logical AND. They are evaluated from left to right.  some predicates like -maxdepth affect the amount of traverse files and should always  be specified first.

So for a file  to get to the end of the expression (were implicit -print predicate will be executed on file) a file should meet both of these conditions: it should have suffix "conf" and be a regular file.

To reverse the condition you can use to prefix it with -not.

find / -name "*.conf"  -not -type f

To specify  -or condition you need to use round brackets (as shell interprets round brackets as metasymbols too, they need to be escaped or put in  quotes)

find /etc \( type f -or type l \)

Summarizing the predicate can be organized into:

• Chain of predicated connected with AND. You do not need to specify AND explicitly, but if you wish to do so you can, for example expr -and expr (or expr -a expr)
• Subexpression ( expr )--  Like in algebraic expressions all predicates in the subexpression are evaluated first and the result of the expression is produced before the next predicate outside of this expression is evaluated. Often used for several predicated connected by OR. (expr -or expr). Which also can be written as  expr -o expr). 
• Negation. -not expr (or ! expr)-- reverses the result of the predicate execution (true to false and vise versa)

For example, to count the number of regular files and directories, do this:

[[email protected] etc]# find /etc -name "*.conf" '(' -type f  -or -type d ')' | wc -l

The number of files without suffix .conf  can be counted as well.

find . ! -name "*.conf" -type f | wc -l

Parentheses must be escaped by a backslash or quotes to prevent Bash from interpreting them as a subshell. Using parentheses, the number of files ending in .txt or .sh can be expressed as

$ find . '(' -name "*.conf" -or -name '*.config' ')' -type f | wc -l

Find as poor man "detective", timestamps related predicates

With so many files in the typical linux filesystem finding  missing files is a regular pasture of sysadmins. Usually you  remember several facts about missing file. among them:

• min and max size of the file in question
• Time interval during which this file was last modified (or created, or accessed)
• Range of sized for the file (min and max)
• Particular phrase inside

There are several predicates in find which can be to test files of iether the access (atime) or modification time(mtime), which is the time a file was last read or written stored in the inode.  There is also the third time stand called creation time ("ctime") which actually is not attribute of the file but a directory in which file is listed and is nothing more then a date when the particular record in the directory was created. 

Fins provides reasonably flexible capabilities of specifying need time interval iether  in days or minutes. Historically, find times were measured in days (ctime, mtime) in connection with the other file ( -newer), but the GNU version extended this capability provided options that allow specify the tike interval in hours (like -min switch).

 find can look for files that were created or modified exactly in the specified interval, older then certain threshold, or newer then certain threshold.

the most common are check for modified time. You can check the modified time, which is the time a file was last written to, by using -newer, -mtime, and -mmin. The -newer switch checks to see whether one file was modified more recently than a specified file. -mtime tests the number of days ago a file was accessed. -mmin allows to specified minutes inread of days.

• To search for files modified N or less days ago include the minus sign before N. For example to find files in /etc directory that were modified today use: find /etc -type f -mtime -1 -ls
• To search for files older than particular number of days, use plus sign followed by the number of days  For example to find files in /data directory older then one year (and this candidates for archiving or deletion)  use: find /data -type f -mtime +365 -ls

  To find files that haven't been changed in more than one day:

  find /etc -name "*.conf" -type f -mtime +0

• to search file that were created N day ago use number without any sign, for example  to find files modified two days ago  use find /etc -type f -mtime 2 -ls

  To find files that were modified the last hour:

  [[email protected] etc]# find /etc -type f -mmin -60
  /etc/sudoers

In other words, i a plus sign (+) precedes the amount of time, find searches for times greater than this amount. If a minus sign (-) precedes the time measurement, find searches for times less than this amount.  Likewise, -min -5 in minutes means “younger than 5 minutes” or “zero to four minutes old”.

In addition to modification time can use the similar conditions with  the creation time. The relevant options are -cnewer, -ctime, and -cmin. The inode timestamp usually, but not always, represents the time the file was created.

Here are options we discussed for reference:

-amin n

File was last accessed n minutes ago.

-anewer file

File was last accessed more recently than file was modified. If file is a symbolic link and the -H  option or the -L  option is in effect, the access time of the file it points to is always used.

-atime n

File was last accessed n*24 hours ago. When find figures out how many 24-hour periods ago the file was last accessed, any fractional part is ignored, so to match -atime +1, a file has to have been accessed at least two days ago.

-cmin n

File's status was last changed n minutes ago.

-cnewer file

File's status was last changed more recently than file was modified. If file is a symbolic link and the -H  option or the -L  option is in effect, the status-change time of the file it points to is always used.

-ctime n

File's status was last changed n*24 hours ago. See the comments for -atime  to understand how rounding affects the interpretation of file status change times.

-empty

File is empty and is either a regular file or a directory.

Searching files of certain  size

The -size predicate tests the size of a file. The default measurement is 512-byte blocks, which is counterintuitive to many users and a common source of errors. Unlike the time-measurement predicates, which have different predicates for different measurements of time, to change the unit of measurement for size you must follow the amount with a b (bytes), c (characters), k (kilobytes), M (megabyte) G (gigabytes).  Like the time measurements, the amount can have a minus sign (-) to test for files smaller than the specified size, or a plus sign (+) to test for larger files.

For example, use this to find log files greater than 1GB:

$ find / -type f  -size +1G

find shows the matching paths on standard output. Historically, the -print  (whihc is the default and can be omitted) or -ls predicates are used to specify format of output. There is also printf option (or action, to be more precise) which allow to print  selected attributes. Printing the paths is the default behavior. As sometime Unix servers often store files from Microsoft Windows where using blanks in filenames are common there is also special option -print0 which allow pipes such filenames to other utilities without automatic splitting them into parts. 

Performing additional actions  of matches files

To perform an action on a successful match, use -exec. The -exec switch runs a program on each matching file and have several modifications:

 As we already studied grep, we will use examples with grep, but it can be any utility or script.

Here is one simple example to find files with certain IP in /etc/hosts  (note usage of option -H in grep):

$ find /etc -type f -name hosts -exec grep -H -10.10.10.10 {} \;

More than one action can be specified. To show the filename after a grep match, include -print.

$ find . -type f -name "*.txt" -exec grep Table {} \; -print

find expects {} to appear by itself (that is, surrounded by whitespace). It can't be combined with other characters, such as in an attempt to form a new pathname. If this is necessary use wrapper script.

The -ok switch works the same way as -exec except that it asks for your condirmation whether the command should run. you cna view it as a debug option.

$ find . -type f -name "*.txt" -ok rm {} \;
< rm ... ./orders.txt > ? n
< rm ... ./advocacy/linux.txt > ? n
< rm ... ./advocacy/old_orders.txt > ? n
				

The -ls action switch lists the matching files with more detail.

The -printf switch use set of macros which indicate what kind of information about the file to print:

• %a-- File's last access time in the format returned by the C ctime function.
• %c-- File's last status change time in the format returned by the C ctime function.
• %f-- File's name with any leading directories removed (only the last element).
• %g-- File's group name, or numeric group ID if the group has no name.
• %h-- Leading directories of file's name (all but the last element).
• %i-- File's inode number (in decimal).
• %m-- File's permission bits (in octal).
• %p-- File's pathname.
• %P-- File's pathname with the name of the command line argument under which it was found removed.
• %s-- File's size in bytes.
• %t-- File's last modification time in the format returned by the C ctime function.
• %u-- File's username, or numeric user ID if the user has no name.

Traversal control

Using find with xargs

The name xargs, pronounced EX-args, means “combine arguments.” xargs builds and executes command lines by gathering together arguments it reads on the standard input. Most often, these arguments are lists of file names generated by find.

This an alterative to using option -exec. The later can dangerous if used directly (for example you can detect level two directories in the deletion list and act accordingly), or it can be slow for a large number of files because the shell is invoked each match, whle most utilities can accept a list of aginments. When you have the option of piping the results to a second command, the execution speed is significantly faster than when using -exec. A pipe generates the results with two commands instead of hundreds or thousands of commands.

Xargs also allows debugging. 

Also some utilities does not accept the list of filenames from the standard input. for example grep is a filter and it treats standard input as the stream to be analyzed, not as the list of files to be processed.  Actually option --switch-stdio-to-filelist for grep would be very useful.

Xargs allot to convert the list of files proficed by find in multiple argumnet for grep or other ustilities invocation.  As suhc is is much better, more modern solution to this problem.

The core functionality of xargs is convert STDIN into iterative calls to whatever program is specified. By default xargs is suppling to each call as much filenames as OS system buffer allows, but you can epscify the exact number.

Let’s say that the output of find is a list of four files, one, two, three, and four. Using xargs, these files could be given to searched by grep  for particular lines much like with -exec option, but in single grep invocation with four arguments,  making processing more efficient and

find | xargs grep pattern

find /var/log -name "*.gz" -type f -size +0 -print | xargs gzip -xv 

Reminder:  -type f matches just plain files, and -size +0 matches files that aren’t zero bytes in size.

Tip

If you have spaces in filenames you need to use -print0 in find and then add an option -0 (zero) to xargs:

find $HOME -name "html" -print0 | xargs -0 grep -i 

Examples (from Bioinformatics Data Skills):
 

Examples

find /tmp -name core -type f -print | xargs /bin/rm -f

find /tmp -name core -type f -print0 | xargs -0 /bin/rm -f


Find files named core  in or below the directory /tmp  and delete them, processing filenames in such a way that file 
or directory names containing single or double quotes, spaces or newlines are correctly handled. The -name  test comes before 
the -type  test in order to avoid having to call stat(2)  
on every file. 

find . -type f -exec file '{}' \;


Runs 'file' on every file in or below the current directory. Notice that the braces are enclosed in single quote marks to protect them 
from interpretation as shell script punctuation. The semicolon is similarly protected by the use of a backslash, though single quotes 
could have been used in that case also.

find / \
\( -perm -4000 -fprintf /root/suid.txt %#m %u %p\n \) , \
\( -size +100M -fprintf /root/big.txt %-10s %p\n \)


Traverse the filesystem just once, listing setuid files and directories into /root/suid.txt  and large files into 
/root/big.txt.

find $HOME -mtime 0

Search for files in your home directory which have been modified in the last twenty-four hours. This command works this way because 
the time since each file was last modified is divided by 24 hours and any remainder is discarded. That means that to match -mtime 
0, a file will have to have a modification in the past which is less than 24 hours ago.

find /sbin /usr/sbin -executable \! -readable -print


Search for files which are executable but not readable.

find . -perm 664


Search for files which have read and write permission for their owner, and group, but which other users can read but not write to. Files 
which meet these criteria but have other permissions bits set (for example if someone can execute the file) will not be matched.

find . -perm -664


Search for files which have read and write permission for their owner and group, and which other users can read, without regard to the 
presence of any extra permission bits (for example the executable bit). This will match a file which has mode 0777, for example.

find . -perm /222


Search for files which are writable by somebody (their owner, or their group, or anybody else).

find . -perm /220
find . -perm /u+w,g+w
find . -perm /u=w,g=w


All three of these commands do the same thing, but the first one uses the octal representation of the file mode, and the other two use 
the symbolic form. These commands all search for files which are writable by either their owner or their group. The files don't have 
to be writable by both the owner and group to be matched; either will do.

find . -perm -220
find . -perm -g+w,u+w


Both these commands do the same thing; search for files which are writable by both their owner and their group.

find . -perm -444 -perm /222 ! -perm /111
find . -perm -a+r -perm /a+w ! -perm /a+x


These two commands both search for files that are readable for everybody ( -perm -444  or -perm -a+r), have at least one 
write bit set ( -perm /222  or -perm /a+w) but are not executable for anybody ( ! -perm /111  and 
! -perm /a+x  
respectively).

cd /source-dir
find . -name .snapshot -prune -o \( \! -name *~ -print0 \)|
cpio -pmd0 /dest-dir


This command copies the contents of /source-dir  to /dest-dir, but omits files and directories named .snapshot  (and 
anything in them). It also omits files or directories whose name ends in ~, but not their contents. The construct -prune -o 
\( ... -print0 \)  is quite common. The idea here is that the expression before -prune  matches things which are to be pruned. 
However, the -prune  action itself returns true, so the following -o  ensures that the right hand side is evaluated only 
for those directories which didn't get pruned (the contents of the pruned directories are not even visited, so their contents are irrelevant). 
The expression on the right hand side of the -o  is in parentheses only for clarity. It emphasises that the -print0  action 
takes place only for things that didn't have -prune  applied to them. Because the default 'and' condition between tests binds 
more tightly than -o, this is the default anyway, but the parentheses help to show what is going on.

find repo/ -exec test -d {}/.svn -o -d {}/.git -o -d {}/CVS ; \
-print -prune

Given the following directory of projects and their associated SCM administrative directories, perform an efficient search for the projects' 
roots:

repo/project1/CVS
repo/gnu/project2/.svn
repo/gnu/project3/.svn
repo/gnu/project3/src/.svn
repo/project4/.git


In this example, -prune  prevents unnecessary descent into directories that have already been discovered (for example we do not 
search project3/src because we already found project3/.svn), but ensures sibling directories (project2 and project3) are found.

 

Locating Files

The Linux locate command consults a database and returns a list of all pathnames containing a certain group of characters, 
much like a fixed-string grep.

[[email protected] etc]# locate ssh_config
/etc/ssh/ssh_config
/usr/share/man/man5/ssh_config.5.gz

The locate database is maintained by a command called updatedb. It is usually executed once a day by Linux distributions. 
For this reason, locate is very fast but useful only in finding files that are at least one day old.

Locate command  is useful for finding man pages, especially in  non-standard locations. After that you can open them with 
less. 

Gotchas

find /tmp -name core -type f -print | xargs /bin/rm -f
Find files named core  in or below the directory /tmp  and delete them. Note that this will work incorrectly if there are 
any filenames containing newlines, single or double quotes, or spaces.  So if the is a file "core findings" it will be interpreted 
two files names

find /tmp -name core -type f -print0 | xargs -0 /bin/rm -f 

Find files named core  in or below the directory /tmp  and delete them, processing filenames in such a way that file 
or directory names containing single or double quotes, spaces or newlines are correctly handled. The -name  test comes before 
the -type  test in order to avoid having to call stat(2)  
on every file. 

find . -type f -exec file '{}' \;



   

      

      
      Top Visited
      
      
      
Switchboard
   
   

      
Latest
   
   

      

      
      Past week
   
   

      

      
      Past month
   







NEWS CONTENTS


Old News ;-) 



Recommended Links


	

Google matched content





Softpanorama Recommended



   
Finding Files

   
Regular expression - Wikipedia

   
https://www.certdepot.net/ 

   
Red Hat Certified 
   System Administrator (RHCSA EX200) – Study Guide

   
Regular expression - Wikipedia

   
Regex Cheat Sheet

   
Regular Expressions (POSIX)

   
Regular Expressions-POSIX 
   Basic Regular Expressions - Wikibooks, open books for an open world

   
Regular Expressions Reference Character Classes

   

   
   Regular Expressions Cookbook Detailed Solutions in Eight Programming Languages Jan Goyvaerts, Steven Levithan 

   

   First-order logic - Wikipedia




Etc

Society


Groupthink :
Two Party System 
as Polyarchy : 

Corruption of Regulators :
Bureaucracies :
Understanding Micromanagers 
and Control Freaks : Toxic Managers :  
Harvard Mafia :
Diplomatic Communication 
: Surviving a Bad Performance 
Review : Insufficient Retirement Funds as 
Immanent Problem of Neoliberal Regime : PseudoScience :
Who Rules America :
Neoliberalism
 : The Iron 
Law of Oligarchy : 
Libertarian Philosophy


Quotes


 
War and Peace 
: Skeptical 
Finance : John 
Kenneth Galbraith :Talleyrand :
Oscar Wilde :
Otto Von Bismarck :
Keynes :
George Carlin :
Skeptics :
Propaganda  : SE 
quotes : Language Design and Programming Quotes :
Random IT-related quotes : 
Somerset Maugham :
Marcus Aurelius :
Kurt Vonnegut :
Eric Hoffer :
Winston Churchill :
Napoleon Bonaparte :
Ambrose Bierce : 
Bernard Shaw : 
Mark Twain Quotes


Bulletin:



Vol 25, No.12 (December, 2013) Rational Fools vs. Efficient Crooks The efficient 
markets hypothesis :

Political Skeptic Bulletin, 2013 :

Unemployment Bulletin, 2010 :
 Vol 23, No.10 
(October, 2011) An observation about corporate security departments :

Slightly Skeptical Euromaydan Chronicles, June 2014 :

Greenspan legacy bulletin, 2008 :
Vol 25, No.10 (October, 2013) Cryptolocker Trojan 
(Win32/Crilock.A) :
Vol 25, No.08 (August, 2013) Cloud providers 
as intelligence collection hubs : 

Financial Humor Bulletin, 2010 :

Inequality Bulletin, 2009 :

Financial Humor Bulletin, 2008 :
Copyleft Problems 
Bulletin, 2004 :

Financial Humor Bulletin, 2011 :

Energy Bulletin, 2010 : 
Malware Protection Bulletin, 2010 : Vol 26, 
No.1 (January, 2013) Object-Oriented Cult :

Political Skeptic Bulletin, 2011 :
Vol 23, No.11 (November, 2011) Softpanorama classification 
of sysadmin horror stories : Vol 25, No.05 
(May, 2013) Corporate bullshit as a communication method  : 
Vol 25, No.06 (June, 2013) A Note on the Relationship of Brooks Law and Conway Law


History:


Fifty glorious years (1950-2000): 
the triumph of the US computer engineering :
Donald Knuth : TAoCP 
and its Influence of Computer Science : Richard Stallman 
: Linus Torvalds  :
Larry Wall  :
John K. Ousterhout : 
CTSS : Multix OS Unix 
History : Unix shell history :
VI editor :
History of pipes concept :
Solaris : MS DOS 
:  Programming Languages History :
PL/1 : Simula 67 :
C :
History of GCC development : 
Scripting Languages :
Perl history   :
OS History : Mail :
DNS : SSH 
: CPU Instruction Sets :
SPARC systems 1987-2006 :
Norton Commander :
Norton Utilities :
Norton Ghost :
Frontpage history :
Malware Defense History :
GNU Screen : 
OSS early history


Classic books:


The Peter 
Principle : Parkinson 
Law : 1984 :
The Mythical Man-Month : 
How to Solve It by George Polya :
The Art of Computer Programming :
The Elements of Programming Style :
The Unix Hater’s Handbook :
The Jargon file :
The True Believer :
Programming Pearls :
The Good Soldier Svejk : 
The Power Elite


Most popular humor pages:



Manifest of the Softpanorama IT Slacker Society :
Ten Commandments 
of the IT Slackers Society : Computer Humor Collection 
: BSD Logo Story :
The Cuckoo's Egg :
IT Slang : C++ Humor 
: ARE YOU A BBS ADDICT? :
The Perl Purity Test :
Object oriented programmers of all nations 
: Financial Humor :
Financial Humor Bulletin, 
2008 : Financial 
Humor Bulletin, 2010 : The Most Comprehensive Collection of Editor-related 
Humor : Programming Language Humor :

Goldman Sachs related humor :

Greenspan humor : C Humor :
Scripting Humor :
Real Programmers Humor :
Web Humor : GPL-related Humor 
: OFM Humor :
Politically Incorrect Humor :
IDS Humor : 
"Linux Sucks" Humor : Russian 
Musical Humor : Best Russian Programmer 
Humor : Microsoft plans to buy Catholic Church 
: Richard Stallman Related Humor :
Admin Humor : Perl-related 
Humor : Linus Torvalds Related 
humor : PseudoScience Related Humor :
Networking Humor :
Shell Humor :
Financial Humor Bulletin, 
2011 : Financial 
Humor Bulletin, 2012 :
Financial Humor Bulletin, 
2013 : Java Humor : Software 
Engineering Humor : Sun Solaris Related Humor :
Education Humor : IBM 
Humor : Assembler-related Humor :
VIM Humor : Computer 
Viruses Humor : Bright tomorrow is rescheduled 
to a day after tomorrow : Classic Computer 
Humor 


The Last but not Least  Technology is dominated by 
two types of people: those who understand what they do not manage and those who manage what they do not understand ~Archibald Putt. 
Ph.D



Copyright © 1996-2021 by Softpanorama Society. www.softpanorama.org 
was initially created as a service to the (now defunct) UN Sustainable Development Networking Programme (SDNP) 
without any remuneration. This document is an industrial compilation designed and created exclusively 
for educational use and is distributed under the Softpanorama Content License. 
Original materials copyright belong 
to respective owners. Quotes are made for educational purposes only 
in compliance with the fair use doctrine.  


FAIR USE NOTICE This site contains 
		copyrighted material the use of which has not always been specifically 
		authorized by the copyright owner. We are making such material available 
		to advance understanding of computer science, IT technology, economic, scientific, and social  
		issues. We believe this constitutes a 'fair use' of any such 
		copyrighted material as provided by section 107 of the US Copyright Law according to which 
such material can be distributed without profit exclusively for research and educational purposes.

This is a Spartan WHYFF (We Help You For Free) 
site written by people for whom English is not a native language. Grammar and spelling errors should 
be expected. The site contain some broken links as it develops like a living tree...









You can use PayPal to to buy a cup of coffee for authors 
of this site 



Disclaimer: 

The statements, views and opinions presented on this web page are those of the author (or 
referenced source) and are 
not endorsed by, nor do they necessarily reflect, the opinions of the Softpanorama society. We do not warrant the correctness 
of the information provided or its fitness for any purpose. The site uses AdSense so you need to be aware of Google privacy policy. You you do not want to be 
tracked by Google please disable Javascript for this site. This site is perfectly usable without 
Javascript. 



Last modified: December 13, 2020