Romance and Rebellion In Software Versioning

joabj writes: Most software releases more or less follow the routine convention of Major.Minor.Bugfix numbering (i.e. Linux 4.2.1). This gives administrators an idea of what updates are major ones and might bring compatibility issues. As Dominic Tarr points out in his essay "Sentimental Versioning," a few projects boldly take on more whimsical schemes for versioning, such as Donald Knuth's use of successive Pi digits to enumerate new updates to TeX, or Node.js's punk-rock careening between major and minor releases. If you break convention, Tarr seems to be arguing, at least do so with panache.

Comments

Semantic Versioning

[bondsbw]

http://semver.org/

Re:Semantic Versioning

[Chris Mattern]

What happens if there are two independent "major" releases at the same time?

Then they should each have their own name, and their own version sequence.

Re:Semantic Versioning

[Junta]

Got an example at hand?

foo 1.2.3 and foo 1.3.4 might both release as independent stable branches. 1.2.3 might release after 1.3.4, and that would be ok. Ditto for foo 2.1.3 releasing before 1.9.20. So in terms of the upstream, it's perfectly capable of describing concurrent releases.

If you refer to giving room to linux distros to ascribe another tier of versioning, that's why packages append their own revision and flavor (e.g. -5.el6 and -10.el7 may refer to both different generations of the package targeted at RHEL/CentOS6 v. 7.

If you are instead referring to some sort of disagreement in how the project moves forward, that's a fork with a rename (e.g. Gnome v. MATE, Trinity v. KDE),

Not seeing how that argument stands against semantic versioning. Arguments can be made whether or not one can meaningfully honor the promise of the versioning for very large, complex projects, but at least for smaller projects it's a reasonable enough approach.

Re:Semantic Versioning

[Junta]

While there is a practical facet of that approach, it misses a lot of things.

For one, if you want *only* bugfixes and *nothing* to change functionally in some app you use (or your confidence in the upstream to make feature changes without regressions is low), then semantic versioning offers a promise that you can use to select what you pursue. libtool speaks strictly only to functional compatibility, but some want to track beyond that promise.

Similarly, it speaks specifically to how API/ABIs work, not things like expectations around it interacts with a human. For example, a UI redesign wouldn't necessarily mean anything according to libtool versioning system, but it may be a huge thing for people trying to use the software, and they may want a way to tell pre-redesign from post-redesign.

Now the duration for which one can chase such areas hoping for backports of fixes, that's probably a big way in which the promise of semantic versions fade quickly (at least without some sort of out-of-band data about how *long* the project in question promises to try to backport).

Re:Semantic Versioning

[rrr00bb5454]

The version numbering should specifically speak of contracts between components, or else it's not robust enough to help with automating things. Roughly speaking: the contract is the header files exported (or IDL files), and an implementation of the contract imports those header files. The header files should contain all documentation that pertains to the contract, and even documentation changes to the contract should bump the contract version up, while the implementation imports the contract just like the client does. The contracts "5.0" and "5.1" are not necessarily compatible in every way, because the interface expanded; which will cause things like structures having incompatible sizes in C, or unimplemented interface members in Java. For this reason, 5.0.20 and 5.1.20 might be the same implementation exposing two different interfaces. Both being version "5" basically means compatibility at the level of source code, and both being "5.1" should mean that they both work with the same contract. That means that there is agreement on: structure members, sizes, which functions exist, their preconditions and postconditions, data layout in buffers passed around, etc. Assuming that "5.7" can use "5.2" should be expressed in an explicit and computable way. A "5.7" component might export a "5.2" interface, but it should be done explicitly. In the real world, there are compatibility outages in places where theoretically things should be compatible. It's almost easier to dispense with version numbers, and simply declare that if A talks to B, then they both import C of the same git commit, or a C in a list of supported interfaces. Otherwise, the versioning is just a bunch of marketing stuff that has little to say about what is actually connected to what.

Sofware versions should stop at 10 . . .

[PolygamousRanchKid]

Some can go up to eleven, but most should stop at 10.

Re:Sofware versions should stop at 10 . . .

[Kenshin]

But the minor number should keep going past 10, just to make things difficult for pedants. :)

"OS X 10.11? Where's OS XI? Oh my god I'm going insane!"

Sure...

[Anonymous Coward]

you could do something whimsical. Alternately, you could not be an asshat. Sematic versioning FTW!

Use Gödel numbering

[vikingpower]

Use one series of primes for major.
Use a second series of primes for minor.
Use a third series of primes for patches/micro/bug fixing.

The three sets of primes should be disjoint.

For each release, multiply major with minor with micro. That is your unique version number.

You may add some sugar by adding powers of these primes for various locales, database compatibility etc. etc.

Re:Use Gödel numbering

[Rob Riggs]

I like it.

P.S. My UID is also semiprime.

Re:Use Gödel numbering

[Anonymous Coward]

And your post number (#50614169) is a triprime.

50614169 = 113 x 307 x 1459

I'm running Chrome 45 and Firefox 41

[wstrucke]

It seems many developers stopped caring about versioning several years ago. I've been torn on whether it was just marketing finally overtaking common sense or too many inexperienced but successful developers showing up and making some poor choices.

Re:I'm running Chrome 45 and Firefox 41

[bluefoxlucid]

People don't consider a lot when they do things. There's an old convention of 0.x being "incomplete", such that we have some rather mature products in pre-1.0 stable releases without all of the features and finalized interfaces which constitute a completed product. There's a newer convention of Major.Minor.Revision, based on the old Major.Minor.Revision, by which "revision" means "nothing new, fixed some defect", while "Minor" means "Something new, works exactly as before if you're not using the old thing", and "Major" means "things that you did in the last major may produce different results in this version; that includes the removal of features we previously deprecated."

Upon these conventions, we've built support conventions. The prior major release, at least, usually gets continued bugfixes, and occasionally feature back-ports. Bugfixes are for people who can't move forward just yet--they need to fix their processes and workflows to use the new version--and need that support, especially for security fixes; while feature back-ports let the client keep up with new developments, accessing some features in the new major which don't depend on new behavior of old features. We usually handle this by giving a shorter and more casual minor-update duration (you get new features when we care to backport them, by user demand, only for 12 months) than we do for bug fixes (the final 6.x release gets bugfixes for an additional 12 months).

Then you have the deviants.

Apple, upon releasing a new Quicktime major, will preemptively stop supporting the last major. When Quicktime 7.0 came out, it fixed major security vulnerabilities in Quicktime 6; Apple provided no updates to Quicktime 6, so those vulnerabilities remained unless you upgraded to a whole new major Quicktime version with new APIs, new features, changed behavior, and some features removed.

Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality. If it worked on release day, it will work in exactly the same way at EOL. Bugfixes may enable previously-broken functionality; they try not to alter functionality such that previous work-arounds start behaving differently, unless the application is so crippled as to be unuseful. This is okay because the scope of a distribution release implies a major change; Ubuntu has a point release system for LTS to signify minor feature updates.

RedHat takes a different, more Apple-like approach: Their point-releases are just inline updates, like Ubuntu LTS; but they're *major* updates, removing old features and subsystems, integrating completely new systems, changing behaviors, and generally breaking all kinds of shit. There's no support for the previous point release, at all; if you call RHEL support, they tell you to update or else they have nothing for you. The difference between RHEL 6.10 and RHEL 7 is functionally similar to the difference between RHEL 6.9 and RHEL 6.10, or RHEL 7 and RHEL 7.1.

Bring that out to Chrome, Firefox, and friends, with an iterated version for every release. Release numbers now have no meaning except "new". They are effectively date stamps, without the benefit of Debian-style releases in which every release is implied a drastic upheaval rather than a possible incremental feature increase. Nothing in the versioning indicates if APIs have changed or been removed, so broad assessment of compatibility risks (e.g. with old protocols, old incorrect rendering behavior, or old extensions) are not as readily assessed.

It goes all the way out to the Linux kernel, which is just nonsense. WhenLinusFeelLikeIt.Otherwise.Bugfix is the Linux kernel's pattern; it's essentially Major.Bugfix with a period in the Major part.

Re:I'm running Chrome 45 and Firefox 41

[petermgreen]

Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality.

Well that's the ideal, whether reality lives up to it is another matter.

Re:I'm running Chrome 45 and Firefox 41

[bluefoxlucid]

The major deviants are mostly Firefox and Chrome, since sometimes you need to pull Firefox up a few versions to get a security fix; they often backport the fixes.

Re:I'm running Chrome 45 and Firefox 41

[kthreadd]

Then you have Ubuntu and Debian, who follow a very clear policy: Each release will receive no updates which change any functionality. If it worked on release day, it will work in exactly the same way at EOL. Bugfixes may enable previously-broken functionality; they try not to alter functionality such that previous work-arounds start behaving differently, unless the application is so crippled as to be unuseful. This is okay because the scope of a distribution release implies a major change; Ubuntu has a point release system for LTS to signify minor feature updates.

Actually, Ubuntu just bumped python3 from 3.4.0 to 3.4.3 in Trusty LTS yesterday.

Re:I'm running Chrome 45 and Firefox 41

[kthreadd]

RedHat takes a different, more Apple-like approach: Their point-releases are just inline updates, like Ubuntu LTS; but they're *major* updates, removing old features and subsystems, integrating completely new systems, changing behaviors, and generally breaking all kinds of shit. There's no support for the previous point release, at all; if you call RHEL support, they tell you to update or else they have nothing for you. The difference between RHEL 6.10 and RHEL 7 is functionally similar to the difference between RHEL 6.9 and RHEL 6.10, or RHEL 7 and RHEL 7.1.

Here you're actually not completely correct. Red Hat does provide Extended Update Support (EUS) as an option to customers that want to standardize on a minor RHEL release for some time, usually two years.

Re:I'm running Chrome 45 and Firefox 41

[bluefoxlucid]

3.4.3 looks like a pure bugfix and improvement release, not a major feature release. They did change some casing in the http.cookies module, which is concerning.

How about time-based versioning?

[Crowd Computing]

It seems that many projects now opt for a regular progression of numbers with or without any major new features. Even Ubuntu releases, formerly the occasion for the introduction of some initially broken new feature, have become boring affairs. Even the well-numbered Linux kernel appears to break the major.minor paradigm. Besides the addition of more and more drivers, was there anything particularly disruptive in the move from Linux 3.19 to Linux 4.0? Beyond the third digit of the bug fix releases, Linux version numbering fall more into the sentimental rather than semantic versioning camp.

Re:How about time-based versioning?

[tomknight]

OpenBSD dees time-based versioning. Every six months, the version number increments by 0.1 - there's a new release every May 1st and Nov 1st. The change in major version number means nothing other than it's gone from x.9 to (x+1).0

Simple.

Key rules.

[jellomizer]

1. Stay Consistent!!! Don't drop your versioning and swap to another one. Like Microsoft, Firefox, to a lesser extent Apple.
2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.
3. Insure development milestones are consistent with the version bumps. So Version 2 to version 3, should be just as large as from version 3 to 4.

The key importance to versioning is so we know what is the newest/newer version and if you have a major version you will expect some compatiblity changes.

Re:Key rules.

[halivar]

What happens when it goes beyond Z? Does it go onto [?

0. I'm on EBCDIC, you insensitive clod!

Re:Key rules.

[Anonymous Coward]

I've grown accustomed to a variation on Microsoft's four-point versioning system. It's officially Major.Minor.Build.Revision, but I've found reversing the meaning of the last two sections to be more helpful. Major.Minor.Revision.Build just works better for me.

Major versions are breaking revisions. The file format is incompatible. The database architecture changed. The network protocol is completely different. That sort of thing. You increment this when you have a major architecture overhaul or when you make a large, breaking change to something fundamental to the program. Remember, if it's not breaking compatibility with the existing assets and output of the current release of the program, it's (probably) not a major revision!

Minor versions are compatible within a major version, but progressive minor versions contain more, better, upgraded, or different features. You increment this when you make a group of feature additions that don't break compatibility with the previous version.

Release versions are bugfixes, but are a production release (or at least had an RC sent for testing). You increment this when you send a build to QA.

Build versions are daily or other builds generated for developer use. You increment this (or your IDE does it for you) when you compile.

All "higher" version segment changes reset "lower" version segments to zero.

Re:Key rules.

[sarguin]

2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.

Names like One, Two, Three, Four, Five, ... sounds good to me ;)

Re:Key rules.

[plover]

Internally, their version numbers are still consistent, but the fact that their product names include numbers (sometimes related to the date, sometimes related to the internal version number, and sometimes related to the previous release) makes for a confusing mess. Windows 3.5, Windows 95, Windows 98, and Windows ME were all built on top of DOS and were not built on the NT kernel. They were all just windowing systems, and none of them deserved to be called an operating system. Underneath, they ran MS-DOS, which was a more or less compatible version of PC-DOS. They were all 16 bit operating systems.

Windows NT 3.5.1 was Microsoft's first actual multitasking OS, followed by NT 4.0, which was followed by Windows 2000 (NT 5.0). XP was Windows NT 5.1, and was when the Windows NT kernel finally went mainstream to the home users (and introduced most to a 32 bit OS.) Vista was NT 6.0. Windows 7 was NT 6.1. Windows 8 is NT 6.2, and Windows 8.1 was NT 6.3. Starting with Windows 10, they actually renumbered the internals so it's reporting itself as NT 10.0.

On top of all of those, you can try to overlay their server versions. At least they're all named according to the year of their intended release.

As marketing is clearly in charge of OS naming at Microsoft, don't look for consistency in future versions. The only thing you can count on is the unpredictability of their naming schemes. Their next release is equally likely to be called Windows 7331, Windows Forever, Windows 64, Windows 11, or Windows 2018. Internally, it'll probably still just report itself as NT 10.1.

Re:Key rules.

[khellendros1984]

Windows releases always have internal version numbers like these. 5.1.2600 < 6.0.6000, and 4.10.1998 < 5.00.2195 < 6.1.7601 (using your example releases)

Re:Key rules.

[glwtta]

2. If you are using names make sure you know which one is greater. Ubuntu method of going up alphabetically is a good example.

I use Medoc Grads Crus in increasing order of subjective quality - pretty much as obvious as it gets.

Re:Key rules.

[toddestan]

Debian uses a version number, but they nickname each release with a character from Toy Story. Kind of like how Apple uses 10.x to version OSX, but also nicknames each release with a type of feline.

KISS

[Moof123]

Please keep this crap simple. It is maddening for secondary tools (ones I don't use daily) to get all cutesy with the Silky Lizard release, which is also known at the 2015 release, but has an about me of 3.2.0.1 hotfix 430. Searching under all three is necessary since everyone adopts a different preferred method to refer to the dang thing.

On the whole I greatly prefer versions that are year.month based so it is very easy to recognize how long in the tooth something is. XYZ 2015.01 tells me it is the January 2015 release.

Re:KISS

[Junta]

On the whole I greatly prefer versions that are year.month based so it is very easy to recognize how long in the tooth something is

Of course there are situations where that really does not matter and fretting about how old a piece of code is pointless worrying. For example, the code to decrypt a DVD hasn't change in an eternity, but there's no good reason to expect a change to be needed on that front. A library dedicated to that purpose might not change because there's no point, not because it's abandoned.

Re:KISS

[hackertourist]

The big drawback of year.month over major.minor is that year.month gives no indication of the magnitude of changes. Can I install 2015.09 and be certain all of the features I use daily are still there? What's the difference in file format between 2014.06 and this new version?
Now I realize major.minor is not an ironclad guarantee either, but it gets me closer than year.month.

So the final version is...

[__aaclcg7560]

Microsoft Windows 42

Re:So the final version is...

[Zero__Kelvin]

You apparently haven't been paying attention. Windows 10 is the final version. I'm not kidding.

I like year-based versioning

[Cro Magnon]

With year-based, I know how old the software is and I know which version is newer. Maybe add something extra to indicate if it's a major change, or if it gets long term support.

if there is limited new functionlaity.

[leuk_he]

If your new version has limited new visible functionality let users vote on a name of the most current release. Can you name the new feartures of android Marshmellow? If nom, you do know the name!

Re:Versions have been marketing bullshit for decad

[leonbev]

Microsoft's version numbering "system" has always been the most confusing to me. They went from actual version numbers (Windows 3, 3.1), to the approximate year they were released (Windows 95, 98, 2000), to weird brand names (XP, Vista), to made up version numbers that aren't actually the real version number reported by the OS * (Windows 7, 8, 8.1), and finally back to an actual version number that matches what the OS says it is (Windows 10).

Bloody hell, man!

* Windows 7 reports as version 6.3 when you use the "ver" command.

Versioning and Releases Are Old School

[friedmud]

We run with a full continuous integration cycle... with continuous release. Our software version is whatever the Git hash is. This is for a large computational science library that's in use by hundreds of researchers around the globe.

You can read about some of our software development methodology here:

http://openresearchsoftware.me...

Although, that's a bit dated now and a newer article has already been accepted by the Journal Of Open Research Software and should be out "real soon now". You can see an early draft of the new paper here:

http://figshare.com/articles/C...

Re:Versioning and Releases Are Old School

[fisted]

with continuous release.

Ain't no rockstar brogrammer got time for releng, right?

Our software version is whatever the Git hash is.

You're saying this as if that was something to be proud of, rather than a demonstration of laziness...

This is for a large computational science library that's in use by hundreds of researchers around the globe.

Thanks for the warning.

Re:Versioning and Releases Are Old School

[Anonymous Coward]

That sounds like the worst versioning scheme I've ever heard of, and requires gobs of research just to determine the order of versions. I assume that it includes the presumption that the tip of the repository is always bug free. Assuming that you have different development branches and a strict testing policy before copying a branch up to mainline, this could be feasible. But in this case, you'd expect that you could have your CI tool also include a strictly monotonically increasing integer to help your users differentiate between two versions. (Seriously, show a little respect! Just because they're researchers doesn't mean they want to waste their time! They have better things to do, which is why they're using your library instead of writing their own from scratch.) You could even have it slap the commit hash to the end of the version for those users who are interested in the commit version. So the twenty-seventh release might look like "27-4ce653b488b3f1a3f929caa136f63f7846303967" -- now it's user-friendly for everyone! :)

To be a little anal about it, you seemed to imply that having hundreds of users was evidence that your versioning scheme was good. Hundreds of users is peanuts for pretty much anything. I didn't review your product, so I could see that the particular niche it fills only has a few hundred researchers. But that doesn't mean it's good, it might just mean it's the only thing out there.

Re:Versioning and Releases Are Old School

[friedmud]

Quick to criticize and call names I see.

You obviously didn't even bother a cursory glance at the two papers I pointed to. We spend a LOT of time doing release engineering... we just build it all into an automated system so that we can do multiple "releases" per day.

We actually test every code change against a large set of our downstream users codes... automatically. Yes, every change... and yes, against _user's_ applications that are built using our library (even users located on the other side of the world). Our continuous integration isn't just internal... it's over all our user's applications. Every time the code changes pass against the dozens of downstream applications the system automatically rolls out a "release" (by merging to our "stable" branch). Our users can use the stable branch (and update daily if they like) without fear of it breaking their codes.

We are proud of using a Git hash for our "version". We do it this way because we want the entire community to move forward together... all the time. It's a major issue in computational science when people use old versions of libraries forever. Again, go read the papers.

Re:Versioning and Releases Are Old School

[friedmud]

Look at my reply to the guy above you for a little more detail.

We _do_ actually test every every code change _before_ it enters a "devel" branch (everything flows through tested pull requests). Part of that testing is actually testing against _downstream_ applications (user's applications). Once it's deemed fit to go into "devel" the PR is merged and a new set of automated testing is kicked off... with more extensive testing against all downstream applications. If that passes then a "release" is automatically done by merging to our "stable" branch (which is actually master).

The entire system (other than pressing "Merge" on the PR) is completely automated... allowing us to roll out several releases per day that are guaranteed to work with all of our user's applications. This gives them the freedom to use the very most up to date version of the library (the master branch) without fear.

As for the version "number" it actually doesn't matter... no one talks about "I'm on version 4ce653b488b3f1a3f929caa136f63f7846303967"... the only question is: "Did you update today?"...

BTW: If we make an incompatible API change (which is rare). _WE_ actually put in PR's to all of our downstream user's applications (currently numbering in the hundreds) to fix their applications.

The purpose of all of this (which is talked about in the papers) is to keep the entire community running on the newest code... all the time. It trades support burden (of old versions) for a burden of always passing extremely rigorous tests. We've found it to be a really positive thing and our userbase is continuing to grow because of it.

About that userbase. This is massively-parallel, scientific and engineering software (the kind that runs on the largest supercomputers in the world). Several hundred users is actually pretty great ;-)

Re:Integer

[fisted]

Done.

Done what exactly? I mean, apart from turning a version number into a meaningless number

Do it with Panache?

[FatdogHaiku]

OK, but I'm still on Panache 0.92.4!
Do I need to update to 1.1.x?
Also, it would seem that certain young women on the internet have Panache x.x.x.

Re:Do it with Panache?

[Virtucon]

Panache got forked. It's now Flamboyance 3.1.4

Re:Do it with Panache?

[FatdogHaiku]

Panache got forked. It's now Flamboyance 3.1.4

I hope the new developers are flexible...

Re:Versions have been marketing bullshit for decad

[dejitaru]

I personally preferred the version numbers or years. When they changed it Me, XP, Vista, and then 7, 8, it annoyed the hell out of me. At least with the version numbers 3.11 or years Windows 98 it was easier to follow. I am glad they finally made Windows 10 kernel ver 10. Now Office is kind of a different story because for one instance they had XP but then switched back to years.

Re: Integer

[kthreadd]

So you released version 111 and some people downloaded it and purchased a support contract. Then you add a major new features in version 112 that due to their awesomeness have to break backward compatibility with version 111, and for that reason the aforementioned customer is not going to upgrade right away... but they did find a bug in version 111 that you are obligated to fix.

Myth number one, new features does not need breaking changes. Take a look at the Linux kernel. Probably the most modern kernel of all time, yet its developers take pride in that they don't break compatibility. New features does not have to come with the price of breaking changes.

Re:Integer

[fisted]

actually has meaning, a larger number is newer.

How innovative. Care to point me at some version numbering schemes that do not have this property?

Re: Integer

[fisted]

new features does not need breaking changes

But sometimes/often they do, and in the situation described by AC this case is assumed. What exactly is your point?

Re:Versions have been marketing bullshit for decad

[Megane]

I think Firefox and Chrome, which are mostly on a quarterly release schedule, should have year-dot-quarter version numbers. But I don't have anything against the Gecko version numbering (which is what current FF version numbers correspond to). But no matter what you do, someone will have borked up browser version checking that will break when you change your version numbering to something that seems more sensible.

As for the Windows version naming, the funny part was how they were ready to call it Windows 9 until they realized just how much stuff (including Java, for fuck's sake!) did if (substr(version, 0, 9) == "Windows 9") to lazily check for Windows 95 and Windows 98 in a single comparison.

Re: Integer

[kthreadd]

That there are actual shipping software that follows this principle and still manages to improve and add new features and capabilities at a high rate. Sometimes people make stupid decisions; no one will ever be able to type ls * without an error in /usr/lib/systemd/system because someone though it was a good idea to put a file there called -.slice there. Now it's part of the API so it has to stay that way. Inconventient, yes. But will it prevent new features and improvements? No.

Cute when it's small, annoying later

[enjar]

Just like kids and puppies, it's cute when they are small, then develops into an annoyance you put up with for decades.

It's also painfully annoying when you have a version of something (e.g. 7.0), then another version contained in the driver file (340.xx), and still another version reported in a OS-unique manner (e.g. A.B.C.D on Windows). Yes, I'm looking at you, nVidia.

Similar case for themed server names versus role-based, owner-based, rack-location-based, physical-location-based -- anything that allows a rational human being to determine something useful about the server in question versus some confused mnemonic about how Gandalf is the mail server, Frodo is the DNS and Bilbo is the VPN gateway.

Shall I come in again?

[hackertourist]

I count four, no, five version numbering schemes:
- romantic
- rebellious
- traditional (major.minor.bugfix)
- marketing (year.month)
- irrational (a.k.a. Mine's Bigger: Firefox, Chrome)

Re:Integer

[Gr8Apes]

Windows 10.

There are 10 kinds of people in the world...

Re:Integer

[fisted]

The "10" in windows 10 is not the version number, it's the marketing name. Their version number is something different which may or may not begin with 10, but at least doesn't bounce up and down and outside of the domain randomly

Re: Integer

[adhdengineer]

its developers take pride in that they don't break compatibility

The fuck you say?

Re:Integer

[Gr8Apes]

Simple enough to figure out.

Re:Integer

[fisted]

It's not like I care about what windows does or does not ...