News for hackers. Stuff that matters.
Re:Windows 10 and .NET Native by pjmlp on Saturday October 03, 2015 @09:53AM (#10323885)
There have been AOT compilers from third party JVM vendors almost since the begining. Used mostly by companies that didn't want to expose their bytecode.

However Sun decided to bet the farm on JIT and was against having AOT compilation on the reference JDK. Meaning anyone that wanted a AOT toolchain for Java had to go shopping.

Now, it appears Oracle is of a different opinion.

"Java Goes AOT" at JVM Language Summit 2015

https://www.youtube.com/watch?v=Xybzyv8qbOc&list=PLX8CzqL3Ar...

Being used to memory safe languages with AOT compilation like Turbo Pascal, Modula-2, Modula-3, Oberon, Delphi, Ada among many others, I also would have prefer that Java and .NET had offered the same type of toolchain from the beginning.

Now almost 20 years later, we need to teach young generations that their default implementations were just that, implementations. As they got used to the (wrong) idea that memory safe languages imply a VM.

Re:Windows 10 and .NET Native by pilif on Saturday October 03, 2015 @10:28AM (#10324005)
Delphi and pascal are memory safe? That's news to me. I have created my fair share of buffer overruns and memory corruption in both of them (they were my first languages I programmed in)
Re:Windows 10 and .NET Native by pjmlp on Saturday October 03, 2015 @10:54AM (#10324084)
Compared to C they are.

You surely were using unsafe constructs explicitly, like taking the address of a variable wiht Addr or @, using pointer manipulation functions.

With C they just happen, given the lack of bounds checking, implicit conversions, automatic decay of arrays into pointers (specially bad as arguments), null terminated strings and undefined behaviours across compilers.

Re:Windows 10 and .NET Native by Roboprog on Saturday October 03, 2015 @01:09PM (#10324525)
Alas, the Swiss version of Algol lost out to the New Jersey version :-(

Bounds checking and non-nullable references are for wussies, after all. That, and a worse-is-better C compiler is easier to implement and thus more "available". (like Joel Spolsky said "Go ugly early")

Re:Windows 10 and .NET Native by thaumasiotes on Saturday October 03, 2015 @03:37PM (#10325071)
Joel didn't say that. You're probably thinking of this piece by Steve Yegge: http://steve-yegge.blogspot.com/2007/02/next-big-language.ht...

But I wouldn't exactly characterize that as advice Steve Yegge wants people to follow, either.

> Back when I was in the Navy, just out of boot camp, an otherwise entirely forgettable petty officer first class instructor of ours offered us, unasked and free of charge, his sage advice on how to pick up women at a bar: "Go ugly early." With this declaration, he had made it clear that he and I thought rather differently about certain things in life.

> If you want to spare yourself a lot of angst in deciding which programming language to use, then I recommend this simple rule: Go ugly early. C++ will go out with you in a heartbeat.

> For my part, I want to encourage people to make their own languages

Re:Windows 10 and .NET Native by Roboprog on Monday October 05, 2015 @11:26AM (#10332400)
Oops. Right. "Worse/ugly is better" was meant as bitter sarcasm, though.
Re:Windows 10 and .NET Native by jksmith on Saturday October 03, 2015 @02:30PM (#10324874)
Haha wussy or not, damn did I get a lot of bullet proof shit done with M2. Now I have to work with the modern version of PL1. The more keywords the better the language, right?
Re:Windows 10 and .NET Native by Roboprog on Saturday October 03, 2015 @03:37PM (#10325070)
Not sure how to interpret the "more keywords" comment. Words do have the advantage that they force people to put a space around them (usually), though, rather than jamming a bunch of operators together, "C/Unix Hoax" style.

  for(;P("\n"),R--;P("|"))for(e=C;e--;P("_"+(*u++/8)%2))P("| "+(*u/4)%2);
http://www.gnu.org/fun/jokes/unix-hoax.html
Re:Windows 10 and .NET Native by lmm on Saturday October 03, 2015 @01:23PM (#10324576)
> Being used to memory safe languages with AOT compilation like Turbo Pascal, Modula-2, Modula-3, Oberon, Delphi, Ada among many others, I also would have prefer that Java and .NET had offered the same type of toolchain from the beginning.

Do those languages offer consistent, defined behaviour on all platforms (e.g. for integer overflow)? Particularly in the context of multithreading - do they have a crossplatform memory model? That to me was the big advantage of the JVM.

Re:Windows 10 and .NET Native by pjmlp on Saturday October 03, 2015 @02:15PM (#10324810)
They had their own set of issues, but not even close to the anything goes of undefined behaviour across C compilers.

That was actually a reason why many of us embraced Java.

C compilers were between K&R and C89.

C++ compilers were even worse with the standard still ongoing.

These other languages suffered from not being adopted by OS vendors and as you remember, back then we used to pay for compilers. So not being part of the official OS compilers was a burden to adoption.

Java being C++ like, more consistent behaviour and free (as beer) won the hearts of many.

Re:Windows 10 and .NET Native by amaranth on Saturday October 03, 2015 @02:18PM (#10324828)
But those have almost nothing to do with using a VM. You can achieve them with your compiler by emitting overflow checks and fences where appropriate to match the defined model.
Re:Windows 10 and .NET Native by Roboprog on Saturday October 03, 2015 @01:12PM (#10324533)
Eiffel is probably another "other" Pascal/Modula descendent.

Java beans uber class invariants :-(