Laxman Vijay

twitter

facebook

instagram

linkedin

Your privacy is important to us. We promise not to send you spam!

Get inspired from our coverage of the latest trends and breakthroughs in the world of gaming and AI.

Learn the newest gaming tech updates with our weekly newsletter


Bard is Google’s version of conversational AI similar to ChatGPT which has taken the internet by storm over the past few months. This is due to the nature of human like conversational abilities by these AI systems, more and more people finding it using for a variety of tasks.

When it comes to conversational AI, Google is undisputed given the amount of research and development they have done over the years in this field. Bard is the next addition in their lineup. Although given the timing, Bard is simply recognised as a competitor to ChatGPT rather than a flagship product from Google.

Bard is based on the Language Model for Dialogue Application or LaMDA which was released 2 years also by Google. 

“Bard seeks to combine the breadth of the world’s knowledge with the power, intelligence and creativity of our large language models. It draws on information from the web to provide fresh, high-quality responses” according to the [announcement blog](https://blog.google/technology/ai/bard-google-ai-search-updates/) from Google.

This new product adds to Google’s portfolio of AI models including LaMDA, PaLM, Imagen and MusicLM. All these provides more tools to enhance generational AI and impacting the creativity space. 

As of now, there is no demo version of Bard similar to how [ChatGPT has one.](http://chat.openai.com) However, Google says, these new features will be integrated into Google search soon. 

Also, Google plans to release developer APIs from next month starting with Language API powered by LaMDA and followed by other models soon.

Google introduces Bard which is a conversational AI similar to ChatGPT.

Google introduces Bard, Its answer to ChatGPT


File archiving is used when one or more files need to be transmitted or stored as efficiently as possible. Linux supports lots of file archival mechanisms. This article describes the most popular ones.

Before looking into those here's a quick definition of compression and archival

**Compression:** Makes the files smaller by removing redundant information.

**Archival:** Combines multiple files into one, which eliminates the overhead in individual files and makes the files easier to transmit.

Simply compression reduces size and archival combines files.

## Compression algorithms:

- gzip
- bzip2
- xz

### gzip:

gzip (GNU zip) is a compression algorithm. It uses the **Lempel-Ziv-Markov (LZMA) chain** algorithm. It is quite fast but the file size may be larger.

```
gzip {filename}
```

The original file is deleted and replaced by the compressed file.

#### Decompression of gzipped files:

Decompression is done using `gunzip` command.

```
gunzip {gzipped filename}
```

- Including `-l` flag will show the compression information without actually compressing/decompressing.

### bzip2:

bzip2 uses a different compression algorithm called **Burrows-Wheeler block sorting**, which can compress files smaller than gzip at the expense of more CPU time.

```
bzip2 {filename}
```

#### Decompression of bzip2'ed files:

Decompression is done using `bunzip2` command.

```
bunzip2 {bunzip2'ed filename}
```

### xz:

xz also uses the LZMA algorithm. It has the benefits of both gzip and bzip2. It compresses quickly and also results in smaller file sizes.

```
xz {filename}
```

#### Decompression of xzed files:

Decompression is done using `unxz` command.

```
unxz {xzed filename}
```

## Archival:

- tar
- zip

### tar:

Tar is a short form of **TApe Archive.** The tar command takes in several files and creates a single output file that can be split up again into the original files. The tar archived file is often called a tarball.

```
tar -f {filename} {options} {files to archive}
```

The tar command has three modes (pass the appropriate flag to mention the mode):

- Create: Make a new archive out of a series of files. (-c)
- Extract: Extract files out of an archive. (-x)
- List: Show the contents without extracting. (-t)

Tar can also compress the resulting archive using the above compression algorithms.

Provide any of the following flags to mention the compression algorithm.

- gzip (-z)
- bzip2 (-j)
- xz (-J)

The `-v` flag can be provided for a verbose result.

Example:

```
tar -cvJf backup.tar.xz projects/
```

This creates a tarball of the `projects` folder that is compressed using **xz** with a filename of backup.tar.xz

The extension can be anything but it is generally preferred to name this way.

- for gzip, it is `.tar.gz` or `.tgz`, `.taz`

- for bzip2, it is `tar.bz2` or `.tb2`, `.tbz`, `.tbz2`, `.tz2`

- for xz, it is `tar.xz`

#### Listing:

You can list the contents inside the archive without actually extracting using the `-t` flag.

Example:

```
tar -tvf backup.tar.xz
```

This command lists the contents of `backup.tar.xz`

#### Unarchival:

Unarchival is done by passing `-x` flag.

Example:

```
tar -xvJf backup.tar.xz
```

This command extracts the file in the same folder. If you wish to change it, pass the `-C` flag. (which will change directory to the specified one, therefore the directory should be present.)

```
tar -C backups -xvJf backup.tar.xz
```

This will extract in backups folder.

In order to extract a specific file/folder from the archive, provide the relative path of the file/folder.

```
tar -xvJf backup.tar.xz projects/project1
```

This will extract only project/project1 from the archive.

**It is important to note that `-f` flag should always precede the filename**

### Zip:

Zip is an archival and compression mechanism. It does both. The compression is lossless. The default compression algorithm is [DEFLATE](https://en.wikipedia.org/wiki/DEFLATE). It is more common than tarballs. It has builtin support in Windows and Mac. Therefore, it is more preferred for archival than tar.

```
zip {options} {output filename} {files to compress}
```

By default, zip will not compress recursively. Therefore in order to compress files/subfolders inside a folder, use `-r` flag.

Example:

```
zip files.zip temp*
```

This will compress all files starting with _temp_.

```
zip -r projects.zip projects
```

This will recursively compress all files inside the projects folder.

#### Unzip:

the `unzip` command is used to extract the contents of the zipped archive.

Example:

```
unzip projects.zip
```

To just list without extracting,

```
unzip -l projects.zip
```

To extract specific files/folders inside the zip,

```
unzip projects.zip projects/project1
```

This is similar to tar.

Thanks for reading :)


Explanation of common compression and archival techniques

Compression and archival in linux


This is a list of useful Linux commands. Most of them are basic and they can be used as a reference for developers.

#### files and directories

- ls => list all files
- ls -a => list all files along with hidden ones
- ls -R => list all files and folders recursively
- ls -l => list in long format (shows more info)

- rm \<filename> => deletes a file
- mv \<filename> \<directory path> => moves a file
- mv \<srcFileName> \<destFileName> => renames a file
- cp \<srcFileName> \<destFileName> => copies file
- cp -R \<srcDir> \<destDir> => copies directory

- cat filename => read contents of a file
- cat > filename => writes to file
- touch filename => creates a file, touch is basically used to change file timestamps. Refer [here](https://www.howtoforge.com/tutorial/linux-touch-command/)

- mkdir directory name => makes a directory
- rmdir directory name => removes a directory
- rm -rf directory name => removes a directory recursively along with the files
- mv dirname1 path or dirname => moves or renames directory

- history => list all commands used in the current session
- clear => clears the terminal screen
- pwd => displays the path of the current working directory.

#### file permissions

File permissions will be provided to users, groups and others (in the same order). They can be provided as numbers or letters.

r - read, w - write, x - execute
u - user, g - group, o - other, a - all

0 - no permission
1 - execute
2 - write
3 - execute + write
4 - read
5 - read + execute
6 - read + write
7 - all

- chmod number filename => gives permissions to user,group and others.

Eg: `chmod 777 ex.txt` => gives all permissions to all users, groups and others.

'+' - gives permission
'-' - removes permission
'=' - assigns the given permission

Eg: `chmod u=rw ex.txt` => gives read/write to user
Eg: `chmod a= ex.txt` => removes all permission to all users.

- chgrp group name filename => changes group for a file
- chown user filename => changes owner of a file

#### input/ output directions

- '>' write (stdout)
  Eg: ls -al > filename => writes the output of "ls -al" to the file. If the file already exists, it is **overwritten**.

- '>>' append (stdout)
  Eg: `echo "hi" >> filename` => appends to the file

- '\<' input

File descriptors : 0 - stdin, 1 - stdout, 2 - stderr

##### Error redirection:

This is used to redirect errors to a log file, rather than cluttering the terminal.

Eg: `cat ex.txt 2> error.log` => tries to read the file, if there is any error, it is written to error.log

Here, '2' is the file descriptor for stderr.

#### working with pipes

##### pg, more and less

Show large text in the terminal as scrollable chunks by piping it to the pg, more or less commands.

Eg: `cat large_file.txt | less` => gives a scrollable viewer.

##### grep

Search for a string in the output by piping to grep.

Eg: `ls | grep key` => shows files that have a string "key".

Flags:

- -i => case insensitive
- -c => displays only count
- -n => displays matching line and number
- -v => displays output that didn't match

Eg: `ls | grep -cv key` => displays count to output that didn't match

- grep can also accept regular expressions. Refer [here](https://www.guru99.com/linux-regular-expressions.html)

##### sort

Sort the contents

Eg: `ls | sort` => displays in alphabetic order

Flags:

- -r => reverse
- -n => numerical
- -f => case insensitive

Eg: `ls -l | sort -nk2` => displays content numerically sorted on the second column. (number of hard links in this case)

#### variables

- VARIABLE=value => Set variables in the session.
- $VARIABLE => gets the value of a variable.
- unset VARIABLE => unsets the variable.

#### networking commands

- ping ip => checks the connection
- dig hostname => performs a dns lookup
- ssh -i key username@ip => connects to a remote computer securely. key is the private key file.
- scp -i key.pem source dest => copies a file. remote location should be `host:file`.
- lsof -i protocol:port => list all processes listening on a port.

Eg: `lsof -i tcp:3000` lists all processes listening to port 3000

#### process management

- top => lists all running process
- kill pid => kills a process with the given process id

#### mount device

- lsblk => list all block devices
- mount device id directory => mount a device to a directory

Eg: `mount /dev/sda4 /ex/mnt`

Flags:

- -a => mounts all devices in /etc/fstab
- -l => lists all mounted devices
- -t => type of filesystem (eg: ext4)

- umount device id => unmounts a device

#### manual

- man command name => shows usage of a command

Thanks for reading :)


Linux

Compression and archival in linux

Useful linux commands

Follow us

Most read articles

Learn the newest gaming tech updates with our weekly newsletter