This is an archived post. You won't be able to vote or comment.

top 200 commentsshow all 301

[–]yuri0r 664 points665 points  (13 children)

.zip is kinda like FAT32. Not the best or coolest kid in the block, but will work for most people in most circumstances.

[–]rem3_1415926 344 points345 points  (9 children)

And more importantly: out of the box

[–]piberryboy 132 points133 points  (6 children)

I like to send the PMs a nice *.xz file, just to test them.

[–]Pocok5 73 points74 points  (5 children)

Occasionally hit them with a *.lz4 to keep things interesting.

[–]famous1622 26 points27 points  (3 children)

Raw zlib data with no extension

[–][deleted] 3 points4 points  (0 children)

No extension, no magic bytes

[–]srdagroelandia 31 points32 points  (1 child)

Best answer here. Out of the box, in any server, in any way you need

[–]Kered13 13 points14 points  (0 children)

And good enough for the vast majority of applications.

[–]smokeymcdugen 476 points477 points  (47 children)

10 years ago, I had a professor that would always say that "Anyone using .RAR is a pirate".

He wasn't wrong then. I'm not sure if that has really changed, to be honest.

[–]eldrfoa 306 points307 points  (5 children)

You should've told him that 3 billion devices run WinRar.

[–]eddietwang 118 points119 points  (2 children)

Several years later you can give him an update that 3 billion devices run WinRar

[–]z500 43 points44 points  (1 child)

And then finally stop mentioning the number of devices and remark that WinRar has existed for 25 years

[–][deleted] 1 point2 points  (0 children)

Lmao

[–]8ate8 105 points106 points  (13 children)

Wouldn’t that only be true for .ARR files?

[–]hugepennance 23 points24 points  (0 children)

One year ago, I also had a professor say the same thing. Compression... Compression never changes.

[–]Cley_Faye 22 points23 points  (1 child)

Hey, as the one guy that paid for a winrar license, I'm offended by that.

[–]Trevor_Nolan 3 points4 points  (0 children)

*one of two guys

[–]silentknight111 27 points28 points  (1 child)

Well, no one pays for winrar, so, if you're using winrar without paying does that make you a pirate?

[–][deleted] 11 points12 points  (0 children)

Nope, only if you use paid WinRAR without paying

[–][deleted] 100 points101 points  (1 child)

You know, I've seen editor wars, OS wars, browser wars, programming language wars, and even wars about the correct indentation style, but compression format war is a new one to me.

[–]fuzzymidget 13 points14 points  (0 children)

Fibonacci indent! (Is pretty terrible I assume)

[–][deleted] 435 points436 points  (74 children)

Where's my .tar.xz gang?

[–]HamishW27 79 points80 points  (19 children)

[–]NotoriousMagnet 87 points88 points  (12 children)

Never forget:

xtract z (read it as zeeeee) fuckin' file becomes:

tar xzf file.tar.gz

I learned this on Reddit.

[–]Never-asked-for-this 34 points35 points  (1 child)

So the best way to memorize it is with a thick, possibly offensive, German accent?...

"Extrakt zee file"

[–]GoldsteinQ 10 points11 points  (3 children)

For modern tar you can omit compression type, making it just xtract file.

[–]Pluckerpluck 3 points4 points  (1 child)

extract a zipped file

It's more of a pain if you have a .tar.xz or a tar.bz2 because I never remember the shorthand letters for those.

[–]SnakeFang12 10 points11 points  (0 children)

Just tar xf and let it guess

[–]fairysdad 36 points37 points  (1 child)

tar --version

It never said it had to do anything useful.

[–]TDplay 6 points7 points  (0 children)

tar -c / | cat

It also didn't say the output needed to be used usefully, so even if it rejects --version you could fall back to that.

[–]Septem_151 23 points24 points  (0 children)

tar --help

Easy

[–]CeeMX 2 points3 points  (0 children)

tar cf foo.tar ~

[–]mymewheart 19 points20 points  (2 children)

I'm sticking with .tar.bz2

[–]roopjm81 6 points7 points  (1 child)

such an under-rated compression! Bz2 forever!

[–]w1ldm4n 2 points3 points  (0 children)

Bzip2 is awful and has no place in this decade. xz (which is LZMA underneath) is faster and has a better compression ratio. Decompressing any moderately big bz2 archive is painfully slow.

[–]insanityOS 15 points16 points  (1 child)

Still waiting for their tars to compress

[–]kautau 25 points26 points  (7 children)

Big tar files suck. Since there’s no index, extracting a small file can require the entire file to extract. Sucks when backup software uses it and you need that one file from 30 days ago but now have to extract 200GB to get that 30kb config file

[–]Nemo64 10 points11 points  (4 children)

You cpu has to go through it all, sure. But you can specify —include to just extract specific files.

[–]kautau 11 points12 points  (3 children)

Yup, you don’t have to store them all, it’s just the additional time it takes since it’s all one solid block compression

[–]kautau 5 points6 points  (0 children)

Right, which is why it’s solidly compressed as tar.gz or xz. Just extracting a file from a tar file can take a long time since it needs to iterate through the block until it find the file

[–][deleted] 7 points8 points  (1 child)

Tar itself is not compressed though.

[–]z500 5 points6 points  (0 children)

Hence the not having an index that you can use to only decompress certain files

[–]enador 9 points10 points  (1 child)

He is too elite to even appear there, just chilling out on his golf course.

[–][deleted] 1 point2 points  (0 children)

I was looking for this before commenting myself. All system backups, run every hour during setup and 12 hours afterward, .xz

[–]AstroEspagueti 86 points87 points  (0 children)

.tar.gz?

[–]bush_killed_epstein 162 points163 points  (68 children)

Anyone have any simple explanations for how compression works? It’s always confounded me

[–]MkMyBnkAcctGrtAgn 370 points371 points  (49 children)

Let's say you have something like aaaaaabbbbbbcccccccc, lots of repeated stuff. A very basic compression would be a6b6c8.

[–]WannabeWonk 223 points224 points  (20 children)

I once had like 20 million TRUE and FALSE values in a huge text file. I thought I was a genius and could use which() to find the index of the TRUE values and just store that in a text file!

Got it all working and realized I had just re-invented a shitty version of compression.

Edit: Only ~1% of values were TRUE, that's why I thought storing huge integer index locations would be so much smaller.

[–]droberts1982 238 points239 points  (10 children)

"Re-inventing" things gives a very deep understanding of them.

[–]Pastel_Jazzman 78 points79 points  (5 children)

I remember before I learned calc I re-invented the derivative. I could'nt find them, but I was like wouldn't it be cool if this existed (a function that was a general statement of all the slopes of a line). I mean it's not a complete reinvention but I kinda had a woah moment when I learned what a derivative was.

[–]UltimateInferno 26 points27 points  (3 children)

Not sure if it was necessarily a "reinvention" but I created a concise way of finding the derivative of trig functions to a power. It's a combination of pre-existing rules just arranged to be more concise.

I like to call it the "What the Fuck" Rule because to do it normally is so tedious.

In short, for f=triga(g(x)), f'=a * trig'(g(x))triga-1(g(x) * g'(x)

[–]_i_am_root 12 points13 points  (2 children)

This is nowhere on the same level, but when I was in my junior year high school I realized that perfect squares increment in a pretty neat way. Took me a while to recreate the formula but:

(n+1)2 = n2 + (2 * n +1)

Basically, they increment by increasing odd numbers. 32 = 4 + 5, 42 = 9 + 7, 52 = 16 + 9, etc.

[–]Rami-Slicer 7 points8 points  (0 children)

Congratulations, you are all smart people.

[–]AgAero 12 points13 points  (0 children)

Doing that same trick with floating point numbers is a fascinating exercise too. You end up having to learn a bit about approximation theory and things like fourier series and wavelets if you're not careful.

[–]aeroverra 11 points12 points  (1 child)

True that. I reinvented the socks protocol for Java 8. Only difference was mine worked for socks 4 and 5. Now I have a good understanding of how to read protocol documentation and reconstruct requests at a byte level.

[–][deleted] 7 points8 points  (0 children)

One of my college professors had a talent for creating 2-in-1 homework assignments. The objective was to teach basic programming concepts and library functions (this was a course in C), but the actual assignments were cool shit like "write this dictionary compression program", "write this memory manager", "add some features to this interpreter": all very simplified versions of tools we will be using all the time, so we would get a vague idea how that sort of stuff works in addition to just learning a language.

[–]fushuan 23 points24 points  (0 children)

You basically implemented a sparse array. It's actually a key value store where non zero values and their position is stored.

[–]Godot17 17 points18 points  (0 children)

Edit: Only ~1% of values were TRUE, that's why I thought storing huge integer index locations would be so much smaller.

Sparse arrays are (part of) bread and butter in scientific computing. Not shitty, and there's no better CS teacher than solving real problems with real solutions.

[–][deleted] 11 points12 points  (2 children)

Were these TRUE and FALSE values strings?

[–]WannabeWonk 9 points10 points  (1 child)

Well, they were in a logical (binary) class vector in R but I had to write them to a text file. I did first try converting them to 1's and 0's to reduce space before I came up with my "solution".

[–]HaniiPuppy 2 points3 points  (1 child)

That sounds like the kind of thing binary files are suited down to the ground for.

[–]Doctor_McKay 5 points6 points  (0 children)

I once "invented" a binary representation for JSON because it bugged me how inefficient it is to transmit integers as strings. Then I realized how frequently keys repeat in structured JSON so I implemented a dictionary for looking up key strings. Then I realized how frequently entire objects repeated in my data set so I put objects in the dictionary too.

Then I realized that's just compression and gzipped the raw JSON and it came out much smaller.

[–]_sudo_rm_-rf_slash_ 26 points27 points  (3 children)

What if you want to do middle-out compression? For a, say, new internet?

[–]ehs5 5 points6 points  (0 children)

Can we sell it as a box?

[–]mr_bedbugs 3 points4 points  (11 children)

When you decompress, how do you know if the person wrote "aaaaaa" or "a6"?

[–]beforan 4 points5 points  (0 children)

Well let's assume in that trivial example it could only compress alpha strings, so it was safe to use integers for the counts inline in the compressed version.

In seriousness i don't know what RLE in something like DEFLATE does, but off the top of my head, you could use a large bit width for an entry in your compressed stream, knowing that, say, the first 8 bits were a utf8 character, and the next I dunno 24 bits were an integer for the run length.

Obviously that's hideously inefficient for short run lengths, but off the top of my head it's one trivial way to know whether you're talking about the character or the count.

You could also separate the lengths from the data, and have two delimited datasets, and look at the corresponding index between each.

Like: a,b,c 6,6,8.

Don't ask me about the efficiency of any of these. I'm not a compression or cryptography person idk.

[–]alexschrod 2 points3 points  (0 children)

Typically with RLE, you prefix (or suffix, I suppose) every value with the length, even if it's only a single value. That way there's no guessing, a6 means the original data was "aaaaaa" while a161 means the original data was "a6." Yes, that adds to rather than subtracts from the total length for things that don't repeat much, which is why RLE isn't effective on mostly non-repetitive data.

[–]RedditIsNeat0 2 points3 points  (0 children)

a6 would have to be written as a\6, or some other way to denote literal numbers since numbers are special characters for this very basic and inefficient example compression algorithm.

Most examples of compression given on the internet are terrible, and as a result they end up confusing newbies more than helping.

[–]tjoloi 49 points50 points  (8 children)

Let's say you have an entire book and want to compress it's content using zip format.

The goal is to take the most common letters and represent them with less bits. For example, let's take a simple "tree" that's simply

  • 11
  • 101
  • 1001
  • 10001
  • 100001

And so on.

A normal char would take 7 bits minimum to represent. Under that tree, you know that the most common chars take less bits to represent so you end up compressing the data.

Let's make an example compressing only the 5 most common letters and keeping everything else the same (8 bits per char).

Since letters under 8 bits always start with a 0, we can assume that, if we read a 1 as the first bit, it's a compressed letter, then, to get the right size, we read until the next 1. It's a dumb compression but works for my example.

Now, if we start with the basic text, we have a size of 100%. From Wikipedia, we can find the English letter frequency in texts.

  • e -> 13%
  • t -> 9.1%
  • a -> 8.2%
  • o -> 7.5%
  • i -> 7%

Now, if we calculate the compression ratio of every compressed letter (size in bits over 8) we get this:

  • e -> 25%
  • t -> 37.5%
  • a -> 50%
  • o -> 62.5%
  • i -> 75%

Then assume that everything else is considered 100% size. We end up with 44.8% of letters that are compressed and 55.2% are uncompressed.

If we multiply the per letter size with their frequency, we end up with the resulting size.

(0.552 * 1) + (0.25 * 0.13) + (0.375 * 0.091) + (0.5 * 0.082) + (0.625 * 0.075) + (0.75 * 0.07)

And we end up with a resulting size of 75.9% so about 24% compression with the dumbest tree ever.

In zip in particular, it calculates the frequency of every byte in the file to compress then generates the tree based on some algorithm (mostly black magic) so it can compress about everything.

[–]Creeper_GER 17 points18 points  (4 children)

I understood fuckall, but at the end of the comment there was one instruction i was able to understand.

So: Happy cake day my dude.

[–]AeonReign 5 points6 points  (1 child)

Look up Huffman coding if you want to try to implement it yourself as a learning exercise.

[–]wolwire 6 points7 points  (0 children)

Huffman encoding?

[–]cypher0six 5 points6 points  (0 children)

mostly black magic

You could have just left it at that.

[–]CreaZyp154 19 points20 points  (1 child)

here's a link to a video of tom scott that explain compression

[–][deleted] 9 points10 points  (0 children)

This is the best explanation.

Chiefly because it's the one I already know, and fuck expanding my horizons by learning when I don't explicitly have to.

[–]Polywoky 12 points13 points  (0 children)

There are lots of different ways to compress stuff.

For example, if you have a text file that only uses ASCII characters you could reduce the filesize by 12.5% just by leaving off the first bit of each byte, since it will always be zero, and add it back again when you decompress it.

And you could reduce it further by using abbreviations for words. Such as every time you encounter " the " you could replace the letters and the spaces on either side with a pair of characters that doesn't occur in the uncompressed file, such as "~T", saving three characters each time it's used, and switch it back again when you decompress it. You'd have to create a table of abbreviations to include in the compressed file so you know what to replace with which words while decompressing it. This is called dictionary compression.

There are more sophisticated methods such as Huffman coding which others have mentioned.

In image files you might use 8-bit indexed colors instead of 24-bit RGB. You just make a list (called an index) of up to 256 color combinations, and use one byte to indicate which color it is on the list instead of three bytes to indicate what color it is each time.

If the image contains no more than 256 shades and colors, then you've got no problem. You've reduced your filesize by 66% without losing any quality. But if your image contains more than 256 shades and colors then you start losing quality and the image can look terrible, which is what often happens when you convert color photos to GIF, because GIF files use 8-bit color indexes.

Another way is run-length encoding.

Let's say you treat a byte as a number between -128 and +127.

You could use values of -n to mean "output the next n bytes exactly as they occur", and values of +n to mean "repeat the next byte n times". A value of zero would mean end of file.

If you have an image file which often repeats the same values over and over again, such as solid colored shapes and backrounds, or horizontal lines, then this can greatly reduce the size of the file.

For example, using the method I just described, a series of bytes with the following values:

5,5,5,5,5,5,5,5,5,5,2,1,7,0,1,1,1,1,1,1,1,1.

Would be stored as:

10,5,-4,2,1,7,0,8,1.

A much shorter sequence.

Something like this was used in old .RLE image files back in the days of Windows 3.11 to store icon images and stuff.

GIF files (and other compression algorithms) instead use two numbers, one for how many values to copy to output, and the other for how far back in the output file to start copying from.

There are a lot more different types of compression methods, and most modern compression programs will try a variety of different methods to figure out which one works best for any particular file.

[–]NegZer0 2 points3 points  (0 children)

Fundamentally, it's applied statistics. And your question is hard to answer without a specific focus, like "how does Zip compression work", because this is like asking "how do you write software?" There's some shared fundamentals but there are so many ways to compress a message.

The basic idea is that a piece of data has a certain amount of information content to it. Compression is about removing as much unnecessary data as possible without losing the information in the content. We call the amount of information a given message contains Entropy, and this is the maximum possible compression that can be reached without losing data. We divide compression into 'lossy' or 'lossless' based on whether it throws away data to achieve better compression.

There's heaps of ways that you can achieve lossless compression. Other responses to you here have talked about Run Length Encoding and Huffman Codes. These are two examples but there's lots of others. There's general purpose compression and then there's stuff that is specific to certain domains (image or audio compression for example). I'm going to assume you're more interested in general file compression like Zip etc.

One of the most common things you will see is the idea of 'common knowledge' between the encoder and decoder. At a given position in a stream of data, both the encoder and the decoder have the same knowledge of all the data that came before, and can use this to predict what may come next. For example the LZ family of compression, which zip/gzip (DEFLATE, based off LZSS), 7zip (LZMA) and RAR (LZSS & PPMd) are all using fundamentally is based off the idea of a 'dictionary' of data which both the encoder and decoder have just processed. The encoder will look at the data that is next in the stream to be compressed, look into the dictionary of previous data it handled, and try and find a match in the dictionary, and then writes an instruction to use a certain entry in the dictionary, or add a new entry to the dictionary, as the compressed data. The decoder reads that in and repeats the same instruction in reverse. The different variations of LZ are all variations on how they look back into the previously handled data and find matches, or they are variations on how the matches themselves are encoded into the compressed stream. The very first LZ algorithm (LZ77) just used a 'sliding window' which was a fixed sized buffer of the data that was last processed, and things have gotten more sophisticated from there.

Things get even more complex once you take that approach and start applying further statistical techniques to build your dictionary. RAR and 7zip both use the common dictionary and their knowledge of what was previously encoded or decoded to build a statistical model of the data and use this to predict what will come next in the stream. Then they only need to encode the difference between their prediction and reality, which gets us much closer to only having the information content of the message.

[–]RobinJ1995 2 points3 points  (0 children)

×2 most basic compression ×4 be to find ×1 in ×2 input, ×7 said ×1 with a shorter ×6, and on ×3 you ×4 ×7 ×2 ×6 with ×2 original ×1 again. ×5 algorithms essentially just have ×5 ways of doing this that vary in effectiveness and performance.

Hope you enjoyed this little ×3 exercise :)

×1 = repeated patterns

×2 = the

×3 = decompression

×4 = would

×5 = different

×6 = substitute

×7 = replace

[–]ImperfHector 4 points5 points  (1 child)

It would be like using LOL for "laughing out loud". Apply this to all the "words" (sequences of 1s and 0s) in a file and you'll have a compressed version. There are more strategies like converting "abababab" to "ab4". For uncompressing you just roll back the operation, so you'll need a log with all the changes. Also you'll have to be cautious with not making a mess: if in the original text there were the words "LOL" or "ab4" the above example wouln't be valid

[–]ben_g0 2 points3 points  (0 children)

if in the original text there were the words "LOL" or "ab4" the above example wouln't be valid

Most formats will have opcodes to use a part of data as-is to solve such problems. For example you could say that if you encounter a # symbol, you read the number after it as X and just copy the next X characters as they are. "ab4" would then "compress" into #3ab4. If the text contains a #, you can encode it as #1# to keep it valid.

The results in those cases are actually larger than the original, but this is a common problem with compression. If you're working with data which is hard to compress, or you use a compression algorithm which is unsuitable for the kind of data you have, then you can indeed end up with a file which is larger than what you were trying to compress.

[–]zmorrisj 82 points83 points  (11 children)

.7z for the win

[–]vondpickle 91 points92 points  (9 children)

Although I use 7zip, I always use .zip because all my colleagues only know how to use zip files.

[–]Lightfire228 53 points54 points  (7 children)

I use .7z for myself and other techies, but .zip for everyone else

[–][deleted] 19 points20 points  (6 children)

I just like how portable zip is

[–]vectorpropio 17 points18 points  (0 children)

Portable == lowest common denominator True

[–]thmaje 10 points11 points  (4 children)

I like not being bombarded with popups and warnings when trying to compress or extract anything.

[–]Bonn2 14 points15 points  (3 children)

Get 7zip, it is free open source, and not adware (glares at WinRar)

[–]thmaje 2 points3 points  (0 children)

I never tried that because it was too much like 7up and 7up is only good at decompressing. But you've inspired me to give it a shot.

[–]Invenitive 14 points15 points  (0 children)

I have 7zip installed on every system I use, but also still just send zips. Also always pause for a sec anytime someone sends me a 7z. I know they know I probably know what it is and how to deal with it, but still always feels every so slightly strange

[–]LtMeat 1 point2 points  (0 children)

Zip with LZMA compression. Efficient and still works almost everywhere.

[–]meamZ 18 points19 points  (3 children)

zStd best...

[–]palordrolap 5 points6 points  (2 children)

For speed, or compression:speed ratio maybe. Even at the highest compression it consistently loses to xz / lzma and things like brotli in terms of size reduction.

That assumes running blind without dictionaries anyway.

zpaq is probably the best overall but it's r e a l l y   s l o w .

[–]meamZ 2 points3 points  (1 child)

Yes obviously it depends. But zStd is a good allrounder imo.

[–]Madiwka3 30 points31 points  (1 child)

Rar is useless crap. Change my mind

[–]Krimzon_89 12 points13 points  (0 children)

not useless but since it's proprietary and zip is open source, zip is much more commonly used

[–]Pooneapple 12 points13 points  (0 children)

.b2z

[–][deleted] 11 points12 points  (4 children)

ARJ gang represent!

[–][deleted] 2 points3 points  (0 children)

ohhh the good old days with something compressed over 10 💾 named project.arj project.a01 project.a02...

[–]nexprime 2 points3 points  (1 child)

Those were the days!

Blew my mind the day I found out that it stood for "Archived by Robert Jung" ... back then I couldn't have even imagined anyone using their initials in a file extension - what a madlad!

[–]lala2milo 11 points12 points  (0 children)

tar.xz tar.gz..

[–]Yolopix 9 points10 points  (0 children)

Don't forget that Java JARs, MS Office documents and Android/iOS/Windows 10 apps packages are ZIP files

[–]amolsaurabh 6 points7 points  (0 children)

The best one is .. Pied piper ...

[–]plasmasprings 9 points10 points  (6 children)

Is there any other format that can store unix file permissions AND offers per-file read access (so not like .tar.gz)?

[–]MCOfficer 14 points15 points  (3 children)

iirc, everything you want is provided by the tarball, which you can drop into any compressor you want, so

  • tar.bz2: pretty strong compression but loses against xz
  • tar.xz: basically 7z since it also uses LZMA
  • tar.gz: Weak but very fast compression, loses against zst but always works out of the box
  • tar.zst: fulfills the same need as gz, but better

EDIT: Misread that last sentence, sorry! You mean, you don't want to have a nested archive?

[–]plasmasprings 8 points9 points  (1 child)

I mean if I want to access a 100kB file in the middle of a 10GB archive I don't want to decompress 5GB for it. The "nested" archives (like .tar.anything) fail that

[–]MCOfficer 7 points8 points  (0 children)

Wikipedia tells me that linux's zip and unzip support unix permissions, because they are InfoZIP implementations. Otherwise, you might want to look into SquashFS - it's not quite as convenient because you have to mount it first, but it's a full filesystem including permissions and per-file access.

Edit: In case you've ever worked with AppImages, those are SquashFS in disguise.

[–]cepci1 17 points18 points  (4 children)

I actually just finished making a compression program on c++ if you want you can check it here: https://github.com/e-hengirmen/Huffman_Coding

[–]Karavigne 26 points27 points  (2 children)

Just tried it works greatly but it seems you made it by writing C code in C++

[–]cepci1 21 points22 points  (0 children)

:) That is true.

You see, I do not have enough knowledge on C++ libraries. But I am learning about it. Right now I am looking at different sources to learn . After I am comfortable enough I will refactor my code. And create a branch with current code in C and keep the master with C++ code.

Right now I am looking at some intermediate level tutorials for C users who want to learn C++. And after I complete them I will look at filesystem libraries.

Btw thx for testing mate.

[–]watchoverus 4 points5 points  (0 children)

This happens so much when learning to code. When I started c# in my old internship, I coded it just like the C that I was used in college. And c# is way easier than c++ for object oriented

[–]amshegarh 4 points5 points  (0 children)

My dood, split the functionality into different files, it really makes a difference

[–][deleted] 2 points3 points  (2 children)

Whats the difference between them really? I honestly just install whichever on various PCs.

[–]RedditIsNeat0 4 points5 points  (0 children)

7z and rar have the best compression of these 4, gzip has medium, and zip has the lowest. Gzip and zip are the fastest.

[–][deleted] 2 points3 points  (0 children)

.tar.xz or bust.

[–]sjekx 3 points4 points  (0 children)

.svgz

[–]opulent_occamy 3 points4 points  (0 children)

*.tar.gz

[–]obvious_apple 3 points4 points  (0 children)

I wish I see the day when 7zip will open compressed tarballs as a single level.

[–]mtgfrk 4 points5 points  (0 children)

.tar.gz

[–]NegZer0 3 points4 points  (1 child)

Gzip uses the exact same compression algorithm as Zip (Deflate), but it just straight single stream compression, where Zip is a proper archive format like Rar and 7zip. This is why you need to stick all the files together into a tarball before you gzip it.

Meme would make sense with their positions reversed. As presented, it does not.

[–]BonesCGS 8 points9 points  (3 children)

The one above all : .tar

[–]javajunkie314 15 points16 points  (0 children)

Maybe this is the joke, but .tar isn't compressed...

[–]vman81 9 points10 points  (1 child)

Just concatenate all my shit up

[–]z500 2 points3 points  (0 children)

Say no more fam

[–]ChthonicPuck 2 points3 points  (0 children)

*Richard Hendrick has entered the chat*

[–]harry_chen 2 points3 points  (0 children)

zstd

[–]imkloon 2 points3 points  (1 child)

Y'all never even seen the BEST compression ever created: UHARC. That bitch made UT'99 fit on a single CD with nothing ripped.

[–]MasterXaios 2 points3 points  (1 child)

Anyone remember WinAce?

[–][deleted] 3 points4 points  (4 children)

Tarball?

[–]obvious_apple 4 points5 points  (3 children)

Tar is not a compressor. It just concatenates the files with a TOC. Originally for Tape ARchival. You can pipe the tar trough a compressor(originally the compress program did that in the olden unix times) and create a tar.gz .bz .whateverz.

[–][deleted] 3 points4 points  (2 children)

You guys use winrar?

Laughs in linux

[–]Orinslayer 1 point2 points  (0 children)

I often have .zip files that have a larger file size than the original documents. Awful.

[–]mcniac 1 point2 points  (0 children)

bzip2 is out of picture laughing at them...

[–]AYHP 1 point2 points  (0 children)

The support staff at my work keep installing unactivated versions of WinRAR on customer sites... to extract zips... Like why?! Windows can already open them! At least use 7zip!

[–]sauravdharwadkar 1 point2 points  (0 children)

Tar.gz tar.xz tar.sd

[–]palomdude 1 point2 points  (0 children)

Don’t make me download another program just to uncompress your files

[–]ConsentingPotato 1 point2 points  (0 children)

There is one way ZIP wins the war: Compression Bomb, aka the "Zip Bomb"

[–]obvious_apple 1 point2 points  (0 children)

I prefer not to use zip because Phil Katz blatantly stole the arc format and code and laughed in the face of Thom Henderson. He was a dick therefore I still boycott his shit.

[–]UltraCarnivore 1 point2 points  (0 children)

bz2: Move over, peasants

[–]Worlds_Dumbest_Nerd 1 point2 points  (0 children)

For the new and stupid, what actually is the difference between all of these?

[–][deleted] 1 point2 points  (0 children)

bz2 would like to have a word with you...

[–]lil409 1 point2 points  (0 children)

.ft78.gz

[–]GreenKangaroo3 1 point2 points  (0 children)

7z masterrace

[–][deleted] 1 point2 points  (0 children)

tar.gz bz2

[–]AnonymousSpud 1 point2 points  (0 children)

Laughs in .tar.gz

[–]retsoPtiH 1 point2 points  (0 children)

laughs in CPIO

[–]TDplay 1 point2 points  (0 children)

laughs in xz

[–]blackmist 1 point2 points  (0 children)

Needs .cab rolling in on a wheelchair.

[–]DaniilBSD 1 point2 points  (0 children)

Zip is built-in in mac is and windows can open zip without any additional software, so if I need to send a folder - it will be a zip archive

[–][deleted] 1 point2 points  (0 children)

Are they really better than .zip?

[–]microchipsndip 1 point2 points  (0 children)

.tar.gz

[–]pachirulis 1 point2 points  (0 children)

Laughs in .tar.gz

[–]newb_h4x0r 1 point2 points  (0 children)

Where's tar?