David Landup

Joris Schellekens

In this tutorial, we'll take a look at examples on how to create a PDF invoice in Python using pText - as well as how to embed files and add outlines.

Creating PDF Invoices in Python with pText

Creating PDF Invoices in Python with borb

<h2 id="introduction">Introduction</h2>
When working with Strings in Java, we oftentimes need to encode them to a specific charset, such as UTF-8.
<blockquote>
UTF-8 represents a variable-width character encoding that uses between one and four eight-bit bytes to represent all valid Unicode code points.
</blockquote>
A code point can represent single characters, but also have other meanings, such as for formatting. &quot;Variable-width&quot; means that it encodes each code point with a different number of bytes (between one and four) and as a space-saving measure, commonly used code points are represented with fewer bytes than those used less frequently.
UTF-8 uses one byte to represent code points from 0-127, making the first 128 code points a one-to-one map with ASCII characters, so UTF-8 is backward-compatible with ASCII.

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: Java encodes all Strings into UTF-16, which uses a minimum of two bytes to store code points. Why would we need to convert to UTF-8 then?

 </div>
 </div>
 </div>
 <blockquote>
Not all input might be UTF-16, or UTF-8 for that matter. You might actually receive an ASCII-encoded String, which doesn't support as many characters as UTF-8. Additionally, not all output might handle UTF-16, so it makes sense to convert to a more universal UTF-8.
</blockquote>
We'll be working with a few Strings that contain Unicode characters you might not encounter on a daily basis - such as <code>č</code>, <code>ß</code> and <code>あ</code>, simulating user input.
Let's write out a couple of Strings:
<pre><code class="hljs">String serbianString = &quot;Šta radiš?&quot;; // What are you doing?
String germanString = &quot;Wie heißen Sie?&quot;; // What&#x27;s your name?
String japaneseString = &quot;よろしくお願いします&quot;; // Pleased to meet you.
</code></pre>
Now, let's leverage the <code>String(byte[] bytes, Charset charset)</code> constructor of a String, to recreate these Strings, but with a different <code>Charset</code>, simulating ASCII input that arrived to us in the first place:
<pre><code class="hljs">String asciiSerbianString = new String(serbianString.getBytes(), StandardCharsets.US_ASCII);
String asciigermanString = new String(germanString.getBytes(), StandardCharsets.US_ASCII);
String asciijapaneseString = new String(japaneseString.getBytes(), StandardCharsets.US_ASCII);

System.out.println(asciiSerbianString);
System.out.println(asciigermanString);
System.out.println(asciijapaneseString);
</code></pre>
Once we've created these Strings and encoded them as ASCII characters, we can print them:
<pre><code class="hljs">��ta radi��?
Wie hei��en Sie?
������������������������������
</code></pre>
While the first two Strings contain just a few characters that aren't valid ASCII characters - the final one doesn't contain any.
To avoid this issue, we can assume that not all input might already be encoded to our liking - and encode it to iron out such cases ourselves. There are several ways we can go about encoding a String to UTF-8 in Java.
Encoding a String in Java simply means injecting certain bytes into the byte array that constitutes a String - providing additional information that can be used to format it once we form a <code>String</code> instance.
<h2 id="usingthegetbytesmethod">Using the getBytes() method</h2>
The <code>String</code> class, being made up of bytes, naturally offers a <code>getBytes()</code> method, which returns the byte array used to create the String. Since encoding is really just manipulating this byte array, we can put this array through a <code>Charset</code> to form it while getting the data.
By default, without providing a <code>Charset</code>, the bytes are encoded using the platform’s default <code>Charset</code> - which might not be UTF-8 or UTF-16. Let's get the bytes of a String and print them out:
<pre><code class="hljs">String serbianString = &quot;Šta radiš?&quot;; // What are you doing?
byte[] bytes = serbianString.getBytes(StandardCharsets.UTF_8);

for (byte b : bytes) {
 System.out.print(String.format(&quot;%s &quot;, b));
}
</code></pre>
This outputs:
<pre><code class="hljs">-59 -96 116 97 32 114 97 100 105 -59 -95 63 
</code></pre>
These are the code points for our encoded characters, and they're not really useful to human eyes. Though, again, we can leverage String's constructor to make a human-readable String from this very sequence. Considering the fact that we've encoded this byte array into <code>UTF_8</code>, we can go ahead and safely make a new String from this:
<pre><code class="hljs">String utf8String = new String(bytes);
System.out.println(utf8String);
</code></pre>
Note: Instead of encoding them through the <code>getBytes()</code> method, you can also encode the bytes through the String constructor:
<pre><code class="hljs">String utf8String = new String(bytes, StandardCharsets.UTF_8);
</code></pre>
This now outputs the exact same String we started with, but encoded to UTF-8:
<pre><code class="hljs">Šta radiš?
</code></pre>
<h2 id="encodeastringtoutf8withjava7standardcharsets">Encode a String to UTF-8 with Java 7 StandardCharsets</h2>
Since Java 7, we've been introduced to the <code>StandardCharsets</code> class, which has several <code>Charset</code>s available such as <code>US_ASCII</code>, <code>ISO_8859_1</code>, <code>UTF_8</code> and <code>UTF-16</code> among others.
Each <code>Charset</code> has an <code>encode()</code> and <code>decode()</code> method, which accepts a <code>CharBuffer</code> (which implements <code>CharSequence</code>, same as a <code>String</code>). In practical terms - this means we can chuck in a String into the <code>encode()</code> methods of a <code>Charset</code>.
The <code>encode()</code> method returns a <code>ByteBuffer</code> - which we can easily turn into a String again.
Earlier when we used our <code>getBytes()</code> method, we stored the bytes we got in an array of bytes, but when using the <code>StandardCharsets</code> class, things are a bit different. We first need to use a class called <code>ByteBuffer</code> to store our bytes. Then, we need to both encode and then decode back our newly allocated bytes. Let's see how this works in code:
<pre><code class="hljs">String japaneseString = &quot;よろしくお願いします&quot;; // Pleased to meet you.

ByteBuffer byteBuffer = StandardCharsets.UTF_8.encode(japaneseString);

String utf8String = new String(byteBuffer.array(), StandardCharsets.UTF_8);
System.out.println(utf8String);
</code></pre>
Running this code results in:
<pre><code class="hljs">よろしくお願いします
</code></pre>
<h2 id="encodeastringtoutf8withapachecommons">Encode a String to UTF-8 with Apache Commons</h2>
The Apache Commons Codec package contains simple encoders and decoders for various formats such as <a target="_blank" href="https://stackabuse.com/encoding-and-decoding-base64-strings-in-java/">Base64</a> and Hexadecimal. In addition to these widely used encoders and decoders, the codec package also maintains a collection of phonetic encoding utilities.
For us to be able to use the Apache Commons Codec, we need to add it to our project as an external dependency.
Using Maven, let's add the <code>commons-codec</code> dependency to our <code>pom.xml</code> file:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;commons-codec&lt;/groupId&gt;
 &lt;artifactId&gt;commons-codec&lt;/artifactId&gt;
 &lt;version&gt;1.15&lt;/version&gt;
&lt;/dependency&gt;
</code></pre>
Alternatively if you're using Gradle:
<pre><code class="hljs">compile &#x27;commons-codec:commons-codec:1.15&#x27;
</code></pre>
Now, we can utilize the utility classes of Apache Commons - and as usual, we'll be leveraging the <code>StringUtils</code> class.
It allows us to convert Strings to and from bytes using various encodings required by the Java specification. This class is null-safe and thread-safe, so we've got an extra layer of protection when working with Strings.
To encode a String to UTF-8 with Apache Common's <code>StringUtils</code> class, we can use the <code>getBytesUtf8()</code> method, which functions much like the <code>getBytes()</code> method with a specified <code>Charset</code>:
<pre><code class="hljs">String germanString = &quot;Wie heißen Sie?&quot;; // What&#x27;s your name?
byte[] bytes = StringUtils.getBytesUtf8(germanString);
String utf8String = StringUtils.newStringUtf8(bytes);
System.out.println(utf8String);
</code></pre>
This results in:
<pre><code class="hljs">Wie heißen Sie?
</code></pre>
Or, you can use the regular <code>StringUtils</code> class from the <code>commons-lang3</code> dependency:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;org.apache.commons&lt;/groupId&gt;
 &lt;artifactId&gt;commons-lang3&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
If you're using Gradle:
<pre><code class="hljs">implementation group: &#x27;org.apache.commons&#x27;, name: &#x27;commons-lang3&#x27;, version: ${version}
</code></pre>
And now, we can use much the same approach as with regular Strings:
<pre><code class="hljs">String germanString = &quot;Wie heißen Sie?&quot;; // What&#x27;s your name?
byte[] bytes = StringUtils.getBytes(germanString, StandardCharsets.UTF_8);
String utf8String = StringUtils.toEncodedString(bytes, StandardCharsets.UTF_8);
System.out.println(utf8String);
</code></pre>
Though, this approach is thread-safe and null-safe:
<pre><code class="hljs">Wie heißen Sie?
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to encode a Java String to UTF-8. We've taken a look at a few approaches - manually creating a String using <code>getBytes()</code> and manipulating them, the Java 7 <code>StandardCharsets</code> class as well as Apache Commons.

Branko Ilic

In this tutorial, we'll take a look at how to encode a String to UTF-8 in Java - using StandardCharsets, getBytes() with ByteBuffer and Apache Commons with examples.

Encode a String to UTF-8 in Java

<h2 id="introduction">Introduction</h2>
Code Delaying (also known as sleeping) is exactly what the name implies, the delaying of code execution for some amount of time. The most common need for code delaying is when we're waiting for some other process to finish, so that we can work with the result of that process. In multi-threaded systems, a thread might want to wait for another thread to finish an operation, to continue working with that result.
Another example could be lessening the strain on a server we're working with. For example, while web scraping (ethically), and following the ToS of the website in question, abiding by the <code>robots.txt</code> file - you might very well want to delay the execution of each request so as to not overwhelm the resources of the server.
Many requests, fired in rapid succession can, depending on the server in question, quickly take up all of the free connections and effectively become a DoS Attack. To allow for breathing space, as well as to make sure we don't negatively impact either the users of the website or the website itself - we'd limit the number of requests sent by delaying each one.
A student, waiting for exam results might furiously refresh their school's website, waiting for news. Alternatively, they might write a script that checks if the website has anything new on it. In a sense, code delay can technically become code scheduling with a valid loop and termination condition - assuming that the delay mechanism in place isn't blocking.
In this article, we'll take a look at how to delay code execution in Python - also known as sleeping.
<h2 id="delayingcodewithtimesleep">Delaying Code with time.sleep()</h2>
One of the most common solutions to the problem is the <code>sleep()</code> function of the built-in <code>time</code> module. It accepts the number of seconds you'd like the process to sleep for - unlike many other languages that are based in milliseconds:
<pre><code class="hljs">import datetime
import time

print(datetime.datetime.now().time())
time.sleep(5)
print(datetime.datetime.now().time())
</code></pre>
This results in:
<pre><code class="hljs">14:33:55.282626
14:34:00.287661
</code></pre>
Quite clearly, we can see a 5s delay between the two <code>print()</code> statements, with a fairly high precision - down to the second decimal place. If you'd like to sleep for less than 1 second, you can easily pass non-whole numbers as well:
<pre><code class="hljs">print(datetime.datetime.now().time())
time.sleep(0.25)
print(datetime.datetime.now().time())
</code></pre>
<pre><code class="hljs">14:46:16.198404
14:46:16.448840
</code></pre>
<pre><code class="hljs">print(datetime.datetime.now().time())
time.sleep(1.28)
print(datetime.datetime.now().time())
</code></pre>
<pre><code class="hljs">14:46:16.448911
14:46:17.730291
</code></pre>
Though, keep in mind that with 2 decimal places, the sleep duration might not be exactly on spot, especially since it's hard to test, given the fact that the <code>print()</code> statements take some (variable) time to execute as well.
However, there's one major downside to the <code>time.sleep()</code> function, very noticeable in multi-threaded environments.
<blockquote>
time.sleep() is blocking.
</blockquote>
It seizes up the thread it's on and blocks it for the duration of the sleep. This makes it unfit for longer waiting times, as it clogs up the thread of the processor during that time period. Additionally, this make it unfit for Asynchronous and Reactive Applications, which oftentimes require real-time data and feedback.
Another thing to note about <code>time.sleep()</code> is the fact that you can't stop it. Once it starts, you can't externally cancel it without terminating the entire program or if you cause the <code>sleep()</code> method itself to throw an exception, which would halt it.
<h2 id="asynchronousandreactiveprogramming">Asynchronous and Reactive Programming</h2>
<blockquote>
Asynchronous Programming revolves around parallel execution - where a task can be executed and finished independent of the main flow.
</blockquote>
In Synchronous Programming - if a Function A calls Function B, it stops execution until Function B finishes execution, after which Function A can resume.
In Asynchronous Programming - if a Function A calls Function B, regardless of its dependence of the result from Function B, both can execute at the same time, and if need be, wait for the other one to finish to utilize each other's results.
<a rel="nofollow noopener" target="_blank" href="https://www.reactivemanifesto.org/">Reactive Programming</a> is a subset of Asynchronous Programming, which triggers code execution reactively, when data is presented, regardless of whether the function supposed to process it is already busy. Reactive Programming relies heavily on Message-Driven Architectures (where a message is typically an event or a command).
Both Asynchronous and Reactive applications are the ones that suffer greatly from blocking code - so using something like <code>time.sleep()</code> isn't a good fit for them. Let's take a look at some non-blocking code delay options.
<h2 id="delayingcodewithasynciosleep">Delaying Code with asyncio.sleep()</h2>
Asyncio is a Python library dedicated to writing concurrent code, and uses the <code>async</code>/<code>await</code> syntax, which might be familiar to developers who have used it in other languages.
Let's install the module via <code>pip</code>:
<pre><code class="hljs">$ pip install asyncio
</code></pre>
Once installed, we can <code>import</code> it into our script and rewrite our function:
<pre><code class="hljs">import asyncio
async def main():
 print(datetime.datetime.now().time())
 await asyncio.sleep(5)
 print(datetime.datetime.now().time())

asyncio.run(main())
</code></pre>
When working with <code>asyncio</code>, we mark functions that run asynchronously as <code>async</code>, and <code>await</code> the results of operations such as <code>asyncio.sleep()</code> that will be finished at some point in the future.
Similar to the previous example, this will print two times, 5 seconds apart:
<pre><code class="hljs">17:23:33.708372
17:23:38.716501
</code></pre>
Though, this doesn't really illustrate the advantage of using <code>asyncio.sleep()</code>. Let's rewrite the example to run a few tasks in parallel, where this distinction is a lot more clear:
<pre><code class="hljs">import asyncio
import datetime

async def intense_task(id):
 await asyncio.sleep(5)
 print(id, &#x27;Running some labor-intensive task at &#x27;, datetime.datetime.now().time())

async def main():
 await asyncio.gather(
 asyncio.create_task(intense_task(1)),
 asyncio.create_task(intense_task(2)),
 asyncio.create_task(intense_task(3))
 )

asyncio.run(main())
</code></pre>
Here, we've got an <code>async</code> function, which simulates a labor-intensive task that takes 5 seconds to finish. Then, using <code>asyncio</code>, we create multiple tasks. Each task can run asynchronously, though, only if we call them asynchronously. If we were to run them sequentially, they'd also execute sequentially.
To call them in parallel, we use the <code>gather()</code> function, which, well, gathers the tasks and executes them:
<pre><code class="hljs">1 Running some labor-intensive task at 17:35:21.068469
2 Running some labor-intensive task at 17:35:21.068469
3 Running some labor-intensive task at 17:35:21.068469
</code></pre>
These are all executed at the same time, and the waiting time for the three of them isn't 15 seconds - it's 5.
On the other hand, if we were to tweak this code to use <code>time.sleep()</code> instead:
<pre><code class="hljs">import asyncio
import datetime
import time

async def intense_task(id):
 time.sleep(5)
 print(id, &#x27;Running some labor-intensive task at &#x27;, datetime.datetime.now().time())

async def main():
 await asyncio.gather(
 asyncio.create_task(intense_task(1)),
 asyncio.create_task(intense_task(2)),
 asyncio.create_task(intense_task(3))
 )

asyncio.run(main())
</code></pre>
We'd be waiting for 5 seconds between each <code>print()</code> statement:
<pre><code class="hljs">1 Running some labor-intensive task at 17:39:00.766275
2 Running some labor-intensive task at 17:39:05.773471
3 Running some labor-intensive task at 17:39:10.784743
</code></pre>
<h2 id="delayingcodewithtimer">Delaying Code with Timer</h2>
The <code>Timer</code> class is a <code>Thread</code>, that can run and execute operations only after a certain time period has passed. This behavior is exactly what we're looking for, though, it's a bit of an overkill to use <code>Thread</code>s to delay code if you're not already working with a multi-threaded system.
The <code>Timer</code> class needs to <code>start()</code>, and can be halted via <code>cancel()</code>. Its constructor accepts an integer, denoting the number of seconds to wait before executing the second parameter - a function.
Let's make a function and execute it via a <code>Timer</code>:
<pre><code class="hljs">from threading import Timer
import datetime

def f():
 print(&quot;Code to be executed after a delay at:&quot;, datetime.datetime.now().time())

print(&quot;Code to be executed immediately at:&quot;, datetime.datetime.now().time())
timer = Timer(3, f)
timer.start()
</code></pre>
This results in:
<pre><code class="hljs">Code to be executed immediately at: 19:47:20.032525
Code to be executed after a delay at: 19:47:23.036206
</code></pre>
The <code>cancel()</code> method comes in really handy if we have multiple functions running, and we'd like to cancel the execution of a function, based on the results of another, or on another condition.
Let's write a function <code>f()</code>, which calls on both <code>f2()</code> and <code>f3()</code>. <code>f2()</code> is called as-is - and returns a random integer between 1 and 10, simulating the time it took to run that function.
<code>f3()</code> is called through a <code>Timer</code> and if the result of <code>f2()</code> is greater than <code>5</code>, <code>f3()</code> is canceled, whereas if <code>f2()</code> runs in the &quot;expected&quot; time of less than <code>5</code> - <code>f3()</code> runs after the timer ends:
<pre><code class="hljs">from threading import Timer
import datetime
import random

def f():
 print(&quot;Executing f1 at&quot;, datetime.datetime.now().time())
 result = f2()
 timer = Timer(5, f3)
 timer.start()
 if (result &gt; 5):
 print(&quot;Canceling f3 since f2 resulted in&quot;, result)
 timer.cancel()

def f2():
 print(&quot;Executing f2 at&quot;, datetime.datetime.now().time())
 return random.randint(1, 10)

def f3():
 print(&quot;Executing f3 at&quot;, datetime.datetime.now().time())

f()
</code></pre>
Running this code multiple times would look something along the lines of:
<pre><code class="hljs">Executing f1 at 20:29:10.709578
Executing f2 at 20:29:10.709578
Canceling f3 since f2 resulted in 9

Executing f1 at 20:29:14.178362
Executing f2 at 20:29:14.178362
Executing f3 at 20:29:19.182505
</code></pre>
<h2 id="delayingcodewithevent">Delaying Code with Event</h2>
The <code>Event</code> class can be used to generate events. A single event can be &quot;listened to&quot; by multiple threads. The <code>Event.wait()</code> function blocks the thread it's on, unless the <code>Event.isSet()</code>. Once you <code>set()</code> an Event, all the threads that waited are awoken and the <code>Event.wait()</code> becomes non-blocking.
This can be used to synchronize threads - all of them pile up and <code>wait()</code> until a certain Event is set, after which, they can dictate their flow.
Let's create a <code>waiter</code> method and run it multiple times on different threads. Each waiter starts working at a certain time and checks if they're still on the hour every second, right before they take an order, which takes a second to fulfill. They'll be working until the Event is set - or rather, their working time is up.
Each waiter will have their own thread, while management resides in the main thread, and call when everyone can call home. Since they're feeling extra generous today, they'll cut the working time and let the waiters go home after 4 seconds of work:
<pre><code class="hljs">import threading
import time
import datetime

def waiter(event, id):
 print(id, &quot;Waiter started working at&quot;, datetime.datetime.now().time())
 event_flag = end_of_work.wait(1)
 while not end_of_work.isSet():
 print(id, &quot;Waiter is taking order at&quot;, datetime.datetime.now().time())
 event.wait(1)
 if event_flag:
 print(id, &quot;Waiter is going home at&quot;, datetime.datetime.now().time())

end_of_work = threading.Event()

for id in range(1, 3):
 thread = threading.Thread(target=waiter, args=(end_of_work, id))
 thread.start()

end_of_work.wait(4)
end_of_work.set()
print(&quot;Some time passed, management was nice and cut the working hours short. It is now&quot;, datetime.datetime.now().time())
</code></pre>
Running this code results in:
<pre><code class="hljs">1 Waiter started working at 23:20:34.294844
2 Waiter started working at 23:20:34.295844
1 Waiter is taking order at 23:20:35.307072
2 Waiter is taking order at 23:20:35.307072
1 Waiter is taking order at 23:20:36.320314
2 Waiter is taking order at 23:20:36.320314
1 Waiter is taking order at 23:20:37.327528
2 Waiter is taking order at 23:20:37.327528
Some time passed, management was nice and cut the working hours short. It is now 23:20:38.310763
</code></pre>
The <code>end_of_work</code> event was used here to sync up the two threads and control when they work and when not to, delaying the code execution by a set time between the checks.
<h2 id="conclusion">Conclusion</h2>
In this guide, we've taken a look at several ways to delay code execution in Python - each applicable to a different context and requirement.
The regular <code>time.sleep()</code> method is pretty useful for most applications, though, it's not really optimal for long waiting times, isn't commonly used for simple scheduling and is blocking.
Using <code>asyncio</code>, we've got an asynchronous version of <code>time.sleep()</code> that we can <code>await</code>.
The <code>Timer</code> class delays code execution and can be canceled if need be.
The <code>Event</code> class generates events that multiple threads can listen to and respond accordingly, delaying code execution until a certain event is set.

Lazar Ristic

In this guide, we'll be taking a look at how to delay code execution/make a time delay/sleep in Python, for both synchronous and asynchronous code with examples.

Python: Make Time Delay (Sleep) for Code Execution

<h2 id="introduction">Introduction</h2>
The digital revolution has changed our lives in many ways. Nowadays, our picture albums, music collections, bookshelves etc. are all digital - binaries written on a disk. Our life and work are shared between a multitude of devices. Companies have development, staging, testing areas and dozens of developers connected to them.
From this shift in our life dynamics emerged two problems: how to preserve the integrity of our data and how to make it synchronized across all of our devices? Enter rsync, a tool that aims and actually succeeds in solving those issues.
First released in 1996 under the <a rel="nofollow noopener" target="_blank" href="https://www.gnu.org/licenses/gpl-3.0.html">GPLv3</a> license, rsync is an open-source file transfer and synchronization tool written in C. It works by comparing sizes and modification times (<code>mtime</code>) to decide which files need to be synchronized, and uses an effective algorithm to minimize network bandwidth for transfers.
Following the <a rel="nofollow noopener" target="_blank" href="https://en.wikipedia.org/wiki/Unix_philosophy">Unix philosophy</a>, rsync is very lightweight, easily configurable and scriptable. It has reached great popularity and ubiquity. Pretty much every Linux Distribution comes with rsync preinstalled; you can even find it on MacOS out of the box!
Of course, it can be built from source as well - the tarball can be found <a rel="nofollow noopener" target="_blank" href="https://rsync.samba.org/">here</a>. For Windows users though, some additional effort is required. It can be used with the Cygwin runtime, or under WSL.
<h2 id="basicrsyncoperations">Basic rsync Operations</h2>
<pre><code class="hljs">$ rsync options source destination
</code></pre>
The syntax is pretty straightforward. You call <code>rsync</code>, list the options and choose the source and destination. All options can be found in rsync's <code>man</code> pages. Let's take a look at the key options we'll be using:
<ul>
<li>
<code>--archive</code> or <code>-a</code> 
This option is an alias for <code>-rlptgoD</code> which boils down to - do a recursive call trying to preserve as much as you can. This includes <code>mtime</code>, permissions and ownership, symlinks, etc. This option is almost always used. Hard Links are not included since tracking them down can be a costly operation. They can be explicitly requested with the <code>-H</code> option.
</li>
<li>
<code>--verbose</code> or <code>-v</code> and <code>--human-readable</code> or <code>h</code>. 
This option, very common with command line programs, forces rsync to log the operations it performs to the standard output stream. Should be skipped in scripts, where the <code>--quiet</code> or <code>-q</code> option is preferred as it produces no output.
</li>
<li>
<code>--compress</code> or <code>-z</code> 
This option uses compression during network transfer to reduce bandwidth. Very desirable and almost always used; same as the <code>--archive</code> option.
</li>
<li>
<code>--dry-run</code> or <code>-n</code> 
This tells rsync to simulate the process and tell us what will be updated or deleted without actually doing anything. Useful for double checking our arguments and dealing with sensitive data.
</li>
<li>
<code>--update</code> or <code>-u</code> 
This option tells rsync to skip files that are newer in the destination than in the source. We will take a deeper look at its effects in the examples below.
</li>
<li>
<code>--del</code> 
This option tells rsync to delete all files in the destination not included in the source argument. Useful for cleaning up temporary files which we don't need anymore but backed up during previous synchronization.
</li>
<li>
<code>--inplace</code> 
The default way rsync works is by copying new files over, and then deleting the data it's substituting. This option tells it to substitute data in-place which doesn't take that much storage in the transfer process. Useful in situations without much storage headroom ie. transfering to a flash drive etc.
</li>
</ul>
<h2 id="rsyncexamples">rsync Examples</h2>
<pre><code class="hljs">$ rsync -avz src dest
</code></pre>
This is the most common way you'll be invoking <code>rsync</code>. Preserve and compress everything, while logging the operations.
For remote locations:
<pre><code class="hljs">$ rsync -avz src user@destination:location
</code></pre>
If you have an external hard disk you'd like to sync the files on - but use two devices to edit them (say, editing photos on a laptop and desktop), the <code>-u</code> flag comes in handy as you might not want <code>rsync</code> to override the more recent work on either of these with their old versions:
<pre><code class="hljs">$ rsync -avuz src /mnt/my_hdd
</code></pre>
<h2 id="rsyncwithremotehosts">rsync with Remote Hosts</h2>
Another thing rsync has going for it the fact that it excels with remote transfers. Using <code>ssh</code> by default (there are other protocols available, it even has its own), it is fully integrated with ssh keyrings. The only caveat is that rsync needs to be installed on both ends, but with such ubiquity, that is almost never an issue.
<h2 id="performingafullsystembackup">Performing a Full System Backup</h2>
Full system backups are common with many *nix users, if they are either particularly worried with their data, or just like experimenting and having a fail safe. We will be using some additional options like <code>-A</code> and <code>-X</code> which preserve ACLs and extended attributes. Some file trees on our file system are unnecessary, so we will be excluding them with the <code>--exclude</code> option. We will also remove any residual file which we have locally removed between the two backups:
<pre><code class="hljs">$ sudo rsync -aAXv --del --exclude={&quot;/dev/*&quot;, &quot;/proc/*&quot;, &quot;/sys/*&quot;, &quot;/tmp/*&quot;, &quot;/run/*&quot;, &quot;/mnt/*&quot;, &quot;/media/*&quot;,&quot;/lost+found&quot;} dest
</code></pre>
<h2 id="dailybackupswithrsyncandcrontab">Daily Backups with rsync and crontab</h2>
Using <a target="_blank" href="/how-to-use-the-crontab-command-in-unix/"><code>crontab</code></a>, we can schedule daily, weekly, monthly or even variable time backups. Let's write a <code>cron</code> expression and schedule our <code>rsync</code> command to run every day at <code>00:00</code>:
<pre><code class="hljs">0 0 * * * root sudo rsync -aAXv --del --exclude={&quot;/dev/*&quot;, &quot;/proc/*&quot;, &quot;/sys/*&quot;, &quot;/tmp/*&quot;, &quot;/run/*&quot;, &quot;/mnt/*&quot;, &quot;/media/*&quot;,&quot;/lost+found&quot;} dest
</code></pre>
In your <code>/etc</code> directory, you can find multiple <code>cron.*</code> directories, corresponding to how often their contents should be checked and run. To create a daily backup of our entire system we can take the above command, place it in a file called, let's say, <code>daily_backup.sh</code> and place it inside <code>/etc/cron.daily/</code>.
This command will run at a specific time, defined by your <code>crontab</code>. Make sure your script is executable and starts with a defining shebang.
<h2 id="conclusion">Conclusion</h2>
What's not to like? A minimal and lightweight command line tool, that is simple to use, able to do a lot of things, easy to put into scripts, and does what it does pretty fast. It's no surprise rsync reached such broad popularity and availability. It does a pretty good job at this one thing everyone, aware of that or not, actually needs.

Dragan Bjekic

In this guide, we'll take a look at examples on how to use the rsync command to sync files, folders and schedule backups in fixed time intervals, on Unix/Linux/MacOS.

How to Use the Rsync Command in Unix

In this guide, we'll take a look at how to call a Python Flask Microservice from a Spring Boot Microservice, using Netflix Eureka and its Service Discovery.

Spring Boot and Flask Microservice Discovery with Netflix Eureka

Marcus Sanatan

Naazneen Jatu

We are going to build a RESTful API using Django without any external libraries or frameworks. Our API will be JSON based and perform CRUD operations on a fictional cart item model.

Creating a REST API in Python with Django

The <code>InputStream</code> class is a high-level class representing any input byte stream in Java. Various subclasses further specify its usage, such as the <code>BufferedInputStream</code>, <code>ByteArrayInputStream</code>, <code>SequenceInputStream</code>, etc.
Needless to say, an <code>InputStream</code> can store any data and in some cases, they store String contents as a byte stream.
In this tutorial, we'll take a look at how to convert an InputStream into a Java String.
Let's start off by making an <code>InputStream</code> that we'll be using throughout the examples. These can come from various sources, but let's make one from a String, to make it easy to verify if the output is correct:
<pre><code class="hljs">String string = &quot;Input data, to be converted into an InputStream.&quot;;
InputStream inputStream = new ByteArrayInputStream(string.getBytes());
</code></pre>
<code>InputStream</code> is an abstract class, and we've used one of its subclasses, <code>ByteArrayInputStream</code> to read the bytes of the String. Now, we've got an <code>InputStream</code> playing the role of actual input, that we can easily verify by comparing to the <code>string</code> instance.
Java has a plethora of classes to work with byte streams, and there's no shortage of options and approaches here. We'll be focusing on a few of them:
<ul>
<li><a href="#inputstreamtostringwithinputstreamreadallbytes">InputStream to String with InputStream.readAllBytes()</a> - Best Approach</li>
<li><a href="#inputstreamtostringwithbytearrayoutputstream">InputStream to String with ByteArrayOutputStream</a></li>
<li><a href="#inputstreamtostringwithinputstreamreader">InputStream to String with InputStreamReader</a></li>
<li><a href="#inputstreamtostringwithbufferedreaderlines">InputStream to String with BufferedReader.lines()</a></li>
<li><a href="#inputstreamtostringwithapachecommons">InputStream to String with Apache Commons</a></li>
</ul>
<h2 id="inputstreamtostringwithinputstreamreadallbytes">InputStream to String with InputStream.readAllBytes()</h2>
Since Java 9, this process has been simplified a lot. The <code>InputStream</code> is very commonly instantiated as a <code>ByteArrayInputStream</code>, before <code>toByteArray()</code> is called to retrieve the bytes from it.
This process is streamlined and replaced by the built-in <code>InputStream.readAllBytes()</code> method, which simply returns the bytes from the <code>InputStream</code> - a much-needed utility method.
The <code>String</code> class accepts a <code>byte</code> array into its constructor, out of which, a <code>String</code> is formed and returned, which makes this the easiest and most readable approach to convert an <code>InputStream</code> into a <code>String</code>:
<pre><code class="hljs">String result = new String(inputStream.readAllBytes());
System.out.println(result);
</code></pre>
This results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
Note: If the <code>InputStream</code> contains more than <code>Integer.MAX_VALUE</code> bytes, the method naturally throws an <code>OutOfMemoryError</code>.
<h2 id="inputstreamtostringwithbytearrayoutputstream">InputStream to String with ByteArrayOutputStream</h2>
For versions prior to Java 9, the fastest way to convert an <code>InputStream</code> into a String is by using the <code>ByteArrayOutputStream</code>.
This approach relies on the fact that we can easily construct Strings from byte arrays, and the fact that <code>ByteArrayOutputStream</code> has a very handy <code>toString()</code> method.
This process is practically the reverse of what we did in the beginning - constructing an <code>InputStream</code> from a String:
<pre><code class="hljs">// Instantiate an OutputStream that&#x27;ll store the data from the InputStream
ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

// For each line of the InputStream, write it to the OutputStream, and move to the next
for (int data = inputStream.read(); data != -1; data = inputStream.read()) {
 byteArrayOutputStream.write(data);
}

// Convert byte array into String
// Optional: You can set a character set via `StandardCharsets` here
String result = byteArrayOutputStream.toString(StandardCharsets.UTF_8);
System.out.println(result);
</code></pre>
The <code>inputStream.read()</code> method reads the next byte in the array, starting at the first one. Here, we save a reference to the first byte as a <code>data</code> of that reading operation, check if it's <code>-1</code> (reached the end of the stream) and move to the next byte with another <code>read()</code> operation.
Running this code results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="inputstreamtostringwithinputstreamreader">InputStream to String with InputStreamReader</h2>
The <code>InputStream</code> and <code>OutputStream</code> classes are a part of the <code>java.io</code> package, which also includes a really handy <code>InputStreamReader</code> class, originally meant as the class to use to read <code>InputStream</code>s.
The <code>InputStreamReader</code> reads the bytes from the stream and decodes them into characters, for which you can optionally also specify via a <code>StandardCharsets</code> enumeration:
<pre><code class="hljs">// Read the InputStream into a Reader
Reader reader = new InputStreamReader(inputStream);

// Instantiate a StringBuilder to save the result
StringBuilder result = new StringBuilder();

// Read each byte and convert into a char, adding to the StringBuilder
for (int data = reader.read(); data != -1; data = reader.read()) {
 result.append((char)data);
}

// Convert StringBuilder to String
System.out.println(result.toString());
</code></pre>
This also results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="inputstreamtostringwithbufferedreader">InputStream to String with BufferedReader</h2>
Instead of a <code>Reader</code>, you can also use a <code>BufferedReader</code>. A <code>BufferedReader</code> stores larger amounts of bytes in a buffer before performing any reading/writing operations. Due to less context switching, this is a more efficient way to read and write large amounts of data, while on smaller amounts, the difference is unnoticeable.
In the previous example, we could've wrapped the <code>InputStreamReader</code> into a <code>BufferedReader</code> instead:
<pre><code class="hljs">BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

StringBuilder sb = new StringBuilder();

for (int data = reader.read(); data != -1; data = reader.read()) {
 sb.append((char)data);
}

System.out.println(sb.toString());
</code></pre>
This results in the same output:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>

 <div class="alert alert-note">
 <div class="flex">
 
 <div class="flex-shrink-0 mr-3">
 <img src="/assets/images/icon-information-circle-solid.svg" class="icon" aria-hidden="true" />
 </div>
 
 <div class="w-full">
 Note: This approach is preferred over the previous one, due to the increased efficiency, even though it may be unnoticeable on smaller amounts of data.

 </div>
 </div>
 </div>
 <h2 id="inputstreamtostringwithbufferedreaderlines">InputStream to String with BufferedReader.lines()</h2>
With Java 8, the <code>BufferedReader</code> class got a new <code>lines()</code> method, which returns a <code>Stream</code> of <code>String</code>s, for each line. This makes it effortless to read an <code>InputStream</code>, using the Stream API:
<pre><code class="hljs">BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream));

String result = reader.lines().collect(Collectors.joining(System.lineSeparator()));

System.out.println(result);
</code></pre>
The <code>Collectors.joining()</code> method can work without us specifying a delimiter, though, it can lead to unexpected results when the input data has new lines. By setting the delimiter to <code>System.lineSeparator()</code>, we're allowing the underlying system's mechanism to kick in for the ends of lines.
This code results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="inputstreamtostringwithapachecommons">InputStream to String with Apache Commons</h2>
Finally, let's take a look at how to achieve this through an external library - Apache Commons, which is present in a significant number of projects.
To use Apache Commons, we'll have to add its dependency to our own project:
<pre><code class="hljs">&lt;dependency&gt;
 &lt;groupId&gt;commons-io&lt;/groupId&gt;
 &lt;artifactId&gt;commons-io&lt;/artifactId&gt;
&lt;/dependency&gt;
</code></pre>
And with that out of the way, we can utilize its <code>IOUtils</code> class:
<pre><code class="hljs">String result = IOUtils.toString(inputStream);
System.out.println(result);
</code></pre>
The method also accepts an optional <code>StandardCharsets</code> enumeration:
<pre><code class="hljs">String result = IOUtils.toString(inputStream, StandardCharsets.UTF_8);
</code></pre>
Running this code results in:
<pre><code class="hljs">Input data, to be converted into an InputStream.
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this tutorial, we've taken a look at how to convert an <code>InputStream</code> into a String in Java.
We've taken a look at the newest approach, by reading all bytes and constructing a String directly, as well as writing them into a <code>ByteArrayOutputStream</code>, before using a <code>Reader</code> and <code>BufferedReader</code> and finally topping it off with the use of Apache Commons' <code>IOUtils</code>.

In this tutorial, we'll take a look at how to convert an InputStream into a Java String, in a plethora of ways with practical examples.

Convert InputStream into a String in Java

In this guide, we'll take a look at how to create a PDF Document in Python, using pText - a library for loading, manipulating and saving PDF documents, with examples.

Creating a PDF Document in Python with pText

Creating a PDF Document in Python with borb

<h2 id="introduction">Introduction</h2>
File access permissions and security are at the heart of *nix-based operating systems. File objects can belong to users and/or groups, and at times they need to be shared with various combinations of those two. There are multiple ways in *nix systems to reinforce secure sharing of these objects.
<blockquote>
We use the <code>chmod</code> utility to change or modify the file permissions.
</blockquote>
This guide discusses file permissions and how we can change them with <code>chmod</code>. While the explanations and code should work for almost all *nix-based systems, this guide was specifically written for Linux.
<h2 id="ownershipandpermissions">Ownership and Permissions</h2>
Before we could get into <code>chmod</code>, let's go over the basics of file and directory ownership in Linux. The files and directories that you find or create have access permissions provided in three categories of owners:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Owners</th>
 <th>Symbolic Representation</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>Users</td>
 <td>u</td>
 <td>The primary owner of the file/directory object</td>
 </tr>
 <tr>
 <td>Groups</td>
 <td>g</td>
 <td>A user can be part of one or many groups</td>
 </tr>
 <tr>
 <td>Others</td>
 <td>o</td>
 <td>Other users who also aren't part of the group</td>
 </tr>
 </tbody>
</table>
These owners can have one or many of the following access permissions assigned:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Permission</th>
 <th>Symbolic Representation</th>
 <th>Octal Representation</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>Read</td>
 <td>r</td>
 <td>4</td>
 <td>Permission to read, copy from directory</td>
 </tr>
 <tr>
 <td>Write</td>
 <td>w</td>
 <td>2</td>
 <td>Permission to write/edit, delete, add new files to directory</td>
 </tr>
 <tr>
 <td>Execute</td>
 <td>x</td>
 <td>1</td>
 <td>Permission to execute the binary</td>
 </tr>
 </tbody>
</table>
Let's get hands-on experience with <code>chmod</code> commands and permissions by first creating an empty file:
<pre><code class="hljs">$ touch temp.txt
</code></pre>
We will also be using the <code>ls -l</code> command very often to check access permissions. The <code>ls</code> command is used to list files, but the <code>-l</code> flag returns them in the long format, which also includes the information regarding access permissions:
<pre><code class="hljs">$ ls -l temp.txt
-rw-r--r-- 1 ubuntu ubuntu 0 Apr 20 22:17 temp.txt
</code></pre>
The left-hand side of the result contains information on access permissions. Though, they're not as intuitive as the two tables from just a moment ago. The result has several components:
<img src="https://stackabuse.s3.amazonaws.com/media/guide-to-chmod-1.jpg" alt="Fig.1 Long List &amp; Permissions Explanation">
The permissions can be split into three parts - each corresponding to the owners in the order - Users, Groups, and Others. You may have also noticed the name of the owners i.e. the user and the group to which the object belongs to.
The order of the permission for each codon of 3 is of the structure <code>rwx</code>. If one of these permissions is unavailable, the missing permission is replaced with a dash (-) like <code>rw-</code>. The other details are related to the file itself: its size, creation date, and name.
<h2 id="thechmodutility">The chmod Utility</h2>
The <code>chmod</code> utility helps us to assign permissions to file/directory objects. It has a special set of arguments, corresponding to the ownership and permissions:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Permission</th>
 <th>Symbolic Representation</th>
 <th>Octal Representation</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>read</td>
 <td>r</td>
 <td>4</td>
 </tr>
 <tr>
 <td>write</td>
 <td>w</td>
 <td>2</td>
 </tr>
 <tr>
 <td>execute</td>
 <td>x</td>
 <td>1</td>
 </tr>
 <tr>
 <td>no permission</td>
 <td>-</td>
 <td>0</td>
 </tr>
 </tbody>
</table>
For each owner, these permissions can be summed (for Octal Representation - e.g. 4+2 = 6 denotes read &amp; write permissions) or combined (for Symbolic Representation - e.g. <code>rw</code> denotes read &amp; write permissions).
This is key to understanding how the <code>chmod</code> command works. Let's modify the access permissions of the <code>temp.txt</code> file, and allow read, write and execute permissions to the User, but disallow any access to the Group and Others.
You can use either Octal Representation or Symbolic Representation for this:
<pre><code class="hljs">$ chmod 700 temp.txt
</code></pre>
<img src="https://stackabuse.s3.amazonaws.com/media/guide-to-chmod-2.jpg" alt="Fig.2 chmod depiction">
The octal notation - <code>700</code> can be broken down as:
<ul>
<li>The first octal integer position corresponds to the User and the number 7 itself is an octal representation of all permissions (<code>rwx</code>) i.e. 4+2+1 = 7.</li>
<li>The second and third octal integer positions correspond to the Group and Others, where the number 0 shows that there aren't any permissions to access the object.</li>
</ul>
Let's take a look at the permission on the <code>temp.txt</code> file now:
<pre><code class="hljs">$ ls -l temp.txt
-rwx------ 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
We can perform the same command, and assign the permissions in much the same way if we rewrite the <code>700</code> argument using the symbolic notation:
<pre><code class="hljs">$ chmod u+rwx,g-rwx,o-rwx temp.txt
</code></pre>
We remove permissions using a <code>-</code> sign, and added by <code>+</code>. When using the symbolic representation, owners are separated by commas <code>,</code>. Here, we've added the <code>rwx</code> permission to <code>u</code>, but removed it from <code>g</code> and <code>o</code>.
This results in the same access permissions:
<pre><code class="hljs">$ ls -l temp.txt
-rwx------ 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
Now, let's consider another command:
<pre><code class="hljs">$ chmod u+rwx,g-rw+x,o-rw+x temp.txt
</code></pre>
Here, we've intertwined pluses and minuses:
<ul>
<li><code>'u+rwx'</code> denotes that the read, write and execute permissions are provided to the User.</li>
<li><code>'g-rw+x'</code> and <code>'o-rw+x'</code> show that the Group and the Others are denied to perform any of the read/write operations but they are allowed to perform executions.</li>
</ul>
This is equivalent to <code>chmod 711 temp.txt</code> using octal representation.
Let's check the file again:
<pre><code class="hljs">$ ls -l temp.txt
-rwx--x--x 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
We can also use an <code>'='</code> sign to set/overwrite permissions to the corresponding owner. The aforementioned command could also be written as:
<pre><code class="hljs">$ chmod u=rwx,g=x,w=x temp.txt
</code></pre>
This, yet again, results in:
<pre><code class="hljs">$ ls -l temp.txt
-rwx--x--x 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
<h2 id="advancedchmodusagesuidguidandstickybits">Advanced chmod Usage - SUID, GUID and Sticky Bits</h2>
Now that the basics of <code>chmod</code> are clear, let's take it one step further by reviewing an extra set of special execution/deletion-only permissions that act as the fourth level of security to the existing read, write and execute permissions. These include:
<table class="table table-striped" style="font-size:15px;overflow-x:auto;">
 <thead>
 <tr>
 <th>Special Permission</th>
 <th>Symbolic Representation</th>
 <th>Octal Representation</th>
 <th>Description</th>
 </tr>
 </thead>
 <tbody>
 <tr>
 <td>SUID (Set UserID)</td>
 <td>rw**s**------</td>
 <td>4</td>
 <td>Execution-Only permission defined at the User Level. It is used to provide user-like privileges to whoever executes the file(s) inside the directory objects.</td>
 </tr>
 <tr>
 <td>SGID (Set GroupID)</td>
 <td>---rw**s**---</td>
 <td>2</td>
 <td>Execution-Only permission defined at the Group Level. It is used to provide group-like privileges to whoever executes the file(s) inside the directory objects.</td>
 </tr>
 <tr>
 <td>Sticky Bit</td>
 <td>------rw**t**</td>
 <td>1</td>
 <td>Defined at the Others Level. It prevents the file or object from getting deleted. Only the Owner or Root can delete the file or object.</td>
 </tr>
 </tbody>
</table>
When calling the <code>chmod</code> utility, and setting the argument - the special permission precedes the regular permissions. If we want to add a special permission to our regular <code>700</code> argument, we simply add a digit beforehand:
<pre><code class="hljs">$ chmod 5700 temp.txt
$ ls -l temp.txt
-rws-----T 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
Here, the <code>5</code> defines the sum of <code>4+1</code>, which is a combination of the SUID and Sticky Bit permission. <code>700</code> represents the <code>'rwx'</code> permission for the Owner only. SUID overrides the owner permission, and whoever executes the file will always execute as the owner of the file. In addition to this, only the owner of the file will be able to delete it. In the output, notice the presence of the character <code>'T'</code>, which denotes that the Sticky Bit is set.
Let's rewrite the command, using symbolic representation:
<pre><code class="hljs">$ chmod u+srwx,g-rwx,o+t-rwx temp.txt
$ ls -l temp.txt
-rws-----T 1 ubuntu ubuntu 0 Apr 20 22:19 temp.txt
</code></pre>
Let's breakdown the argument by commas, since it's getting a bit long:
<ul>
<li><code>u+srwx</code>: The user has a <code>SUID</code> permission attached to it, along with <code>rwx</code>.</li>
<li><code>g-rwx</code>: The group is devoid of the <code>rwx</code> permissions.</li>
<li><code>o+t-rwx</code>: The <code>+t</code> denotes the addition of a <code>Sticky Bit</code> permission and the others are devoid of the <code>rwx</code> permissions.</li>
</ul>
If you happen to have another user, try switching to that user and check if you can delete the file. You should be getting a prompt just like this:
<pre><code class="hljs">$ sudo su unknown
$ rm temp.txt
rm: remove write-protected regular empty file &#x27;temp.txt&#x27;?
</code></pre>
<h2 id="conclusion">Conclusion</h2>
In this guide, we learned about file and directory ownership and permissions in Linux. We then used <code>chmod</code> to modify them. These commands can be quite useful in securing the files or directories with much ease in *nix-based Operating Systems.

Sathiya Sarathi Gunasekaran

In this guide, we discuss file ownership and permissions in Unix/Linux systems, and how to change them with chmod, through practical examples and explanations.